@elizaos/plugin-twitter 1.2.0 → 1.2.2

package/README.md

@@ -17,7 +17,7 @@ This package provides Twitter/X integration for the Eliza AI agent using the off
    TWITTER_API_SECRET_KEY=xxx
    TWITTER_ACCESS_TOKEN=xxx
    TWITTER_ACCESS_TOKEN_SECRET=xxx
-   TWITTER_POST_ENABLE=true
+   TWITTER_ENABLE_POST=true
    TWITTER_POST_IMMEDIATELY=true
    ```
 5. **Run:** `bun start`
@@ -34,6 +34,7 @@ This package provides Twitter/X integration for the Eliza AI agent using the off
 - ✅ **Advanced timeline algorithms** with weighted scoring
 - ✅ **Comprehensive caching system**
 - ✅ **Built-in rate limiting and retry mechanisms**
+- ✅ **Discovery service** for autonomous content discovery and growth
 
 ## Prerequisites
 
@@ -122,12 +123,11 @@ TWITTER_ACCESS_TOKEN_SECRET=your_token_secret_here   # Regenerate after permissi
 
 # Basic Configuration
 TWITTER_DRY_RUN=false              # Set to true to test without posting
-TWITTER_POST_ENABLE=true           # Set to true to enable auto-posting
+TWITTER_ENABLE_POST=true           # Enable autonomous tweet posting
 
 # Optional: Posting Configuration
 TWITTER_POST_IMMEDIATELY=true      # Post on startup (great for testing)
-TWITTER_POST_INTERVAL_MIN=90       # Minimum minutes between posts
-TWITTER_POST_INTERVAL_MAX=180      # Maximum minutes between posts
+TWITTER_POST_INTERVAL=120          # Minutes between posts (default: 120)
 ```
 
 ### Step 5: Run Your Bot
@@ -162,41 +162,91 @@ TWITTER_API_SECRET_KEY=             # Consumer API Secret
 TWITTER_ACCESS_TOKEN=               # Access Token (with write permissions)
 TWITTER_ACCESS_TOKEN_SECRET=        # Access Token Secret
 
-# Basic Configuration
+# Core Configuration
 TWITTER_DRY_RUN=false              # Set to true for testing without posting
 TWITTER_TARGET_USERS=              # Comma-separated usernames to target (use "*" for all)
 TWITTER_RETRY_LIMIT=5              # Maximum retry attempts for failed operations
-TWITTER_POLL_INTERVAL=120          # Timeline polling interval (seconds)
-
-# Post Generation Settings
-TWITTER_POST_ENABLE=false          # Enable autonomous tweet posting
-TWITTER_POST_INTERVAL_MIN=90       # Minimum interval between posts (minutes)
-TWITTER_POST_INTERVAL_MAX=180      # Maximum interval between posts (minutes)
-TWITTER_POST_IMMEDIATELY=false     # Post immediately on startup
-TWITTER_POST_INTERVAL_VARIANCE=0.2 # Random variance factor for posting intervals
-
-# Interaction Settings
-TWITTER_SEARCH_ENABLE=true         # Enable timeline monitoring and interactions
-TWITTER_INTERACTION_INTERVAL_MIN=15    # Minimum interval between interactions (minutes)
-TWITTER_INTERACTION_INTERVAL_MAX=30    # Maximum interval between interactions (minutes)
-TWITTER_INTERACTION_INTERVAL_VARIANCE=0.3  # Random variance for interaction intervals
-TWITTER_AUTO_RESPOND_MENTIONS=true     # Automatically respond to mentions
-TWITTER_AUTO_RESPOND_REPLIES=true      # Automatically respond to replies
-TWITTER_MAX_INTERACTIONS_PER_RUN=10    # Maximum interactions processed per cycle
-
-# Timeline Algorithm Configuration
-TWITTER_TIMELINE_ALGORITHM=weighted    # Algorithm: "weighted" or "latest"
-TWITTER_TIMELINE_USER_BASED_WEIGHT=3   # Weight for user-based scoring
-TWITTER_TIMELINE_TIME_BASED_WEIGHT=2   # Weight for time-based scoring  
-TWITTER_TIMELINE_RELEVANCE_WEIGHT=5    # Weight for relevance scoring
-
-# Advanced Settings
-TWITTER_MAX_TWEET_LENGTH=4000      # Maximum tweet length (for threads)
-TWITTER_DM_ONLY=false             # Only interact via direct messages
-TWITTER_ENABLE_ACTION_PROCESSING=false  # Enable timeline action processing
-TWITTER_ACTION_INTERVAL=240       # Action processing interval (minutes)
+
+# Feature Toggles
+TWITTER_ENABLE_POST=false          # Enable autonomous tweet posting
+TWITTER_ENABLE_REPLIES=true        # Enable mention and reply handling
+TWITTER_ENABLE_ACTIONS=false       # Enable timeline actions (likes, retweets, quotes)
+TWITTER_ENABLE_DISCOVERY=          # Enable discovery service (defaults to true if ACTIONS enabled)
+
+# Timing Configuration (all in minutes)
+TWITTER_POST_INTERVAL=120          # Interval between autonomous posts (default: 120)
+TWITTER_ENGAGEMENT_INTERVAL=30     # Interval for all interaction cycles (default: 30)
+TWITTER_DISCOVERY_INTERVAL=30      # Interval for discovery cycles (default: 30)
+
+# Engagement Limits
+TWITTER_MAX_ENGAGEMENTS_PER_RUN=10 # Maximum interactions per engagement cycle
+TWITTER_MAX_TWEET_LENGTH=280       # Maximum tweet length
+
+# Discovery Service Settings
+TWITTER_MIN_FOLLOWER_COUNT=100     # Minimum followers for accounts to follow
+TWITTER_MAX_FOLLOWS_PER_CYCLE=5    # Maximum accounts to follow per discovery cycle
 ```
 
+## 🔍 Discovery Service
+
+The Twitter Discovery Service enables autonomous content discovery and engagement, helping your agent build a following and interact with relevant content on Twitter.
+
+### Overview
+
+The discovery service autonomously:
+- Searches for content related to your agent's topics
+- Identifies high-quality accounts to follow
+- Engages with relevant tweets through likes, replies, and quotes
+- Builds up your agent's timeline by following interesting accounts
+
+### Configuration
+
+```bash
+# Enable discovery service (defaults to true if TWITTER_ENABLE_ACTIONS=true)
+TWITTER_ENABLE_DISCOVERY=true
+
+# Discovery interval in minutes (default: 30)
+TWITTER_DISCOVERY_INTERVAL=30
+
+# Minimum follower count for accounts to follow (default: 100)
+TWITTER_MIN_FOLLOWER_COUNT=100
+
+# Maximum accounts to follow per cycle (default: 5)
+TWITTER_MAX_FOLLOWS_PER_CYCLE=5
+
+# Maximum engagements per cycle (default: 10)
+TWITTER_MAX_ENGAGEMENTS_PER_RUN=10
+```
+
+### How It Works
+
+1. **Content Discovery**: Searches for tweets containing your agent's topics
+2. **Account Scoring**: Scores accounts based on quality (follower count) and relevance
+3. **Tweet Scoring**: Scores tweets for engagement based on relevance:
+   - Like: score > 0.6
+   - Reply: score > 0.8
+   - Quote: score > 0.85
+4. **Memory System**: Tracks engaged tweets and followed accounts to avoid duplicates
+
+### Character Configuration
+
+The discovery service uses your agent's character configuration:
+
+```json
+{
+  "name": "YourAgent",
+  "topics": [
+    "artificial intelligence",
+    "machine learning",
+    "web3",
+    "blockchain"
+  ],
+  "bio": "AI researcher interested in decentralized systems"
+}
+```
+
+If topics aren't specified, the service extracts them from the bio.
+
 ## 🎯 Common Use Cases
 
 ### Just Want to Post Tweets?
@@ -208,9 +258,10 @@ TWITTER_API_SECRET_KEY=xxx
 TWITTER_ACCESS_TOKEN=xxx        # Must have write permissions!
 TWITTER_ACCESS_TOKEN_SECRET=xxx
 
-TWITTER_POST_ENABLE=true
+TWITTER_ENABLE_POST=true
 TWITTER_POST_IMMEDIATELY=true   # Great for testing
-TWITTER_SEARCH_ENABLE=false     # Disable interactions
+TWITTER_ENABLE_REPLIES=false    # Disable interactions
+TWITTER_ENABLE_ACTIONS=false    # Disable timeline actions
 ```
 
 ### Want Full Interaction Bot?
@@ -222,10 +273,10 @@ TWITTER_API_SECRET_KEY=xxx
 TWITTER_ACCESS_TOKEN=xxx
 TWITTER_ACCESS_TOKEN_SECRET=xxx
 
-TWITTER_POST_ENABLE=true
-TWITTER_SEARCH_ENABLE=true
-TWITTER_AUTO_RESPOND_MENTIONS=true
-TWITTER_AUTO_RESPOND_REPLIES=true
+TWITTER_ENABLE_POST=true
+TWITTER_ENABLE_REPLIES=true
+TWITTER_ENABLE_ACTIONS=true      # Enables likes, retweets, quotes
+TWITTER_ENABLE_DISCOVERY=true    # Enables growth features
 ```
 
 ### Testing Without Posting?
@@ -233,7 +284,7 @@ TWITTER_AUTO_RESPOND_REPLIES=true
 ```bash
 # Dry run mode
 TWITTER_DRY_RUN=true            # Simulates all actions
-TWITTER_POST_ENABLE=true
+TWITTER_ENABLE_POST=true
 TWITTER_POST_IMMEDIATELY=true
 ```
 
@@ -265,7 +316,7 @@ Wrong credentials or using OAuth 2.0 instead of OAuth 1.0a.
 ### Bot Not Posting Automatically
 
 **Checklist:**
-- ✅ Is `TWITTER_POST_ENABLE=true`?
+- ✅ Is `TWITTER_ENABLE_POST=true`?
 - ✅ Is `@elizaos/plugin-bootstrap` installed?
 - ✅ Does your character have `postExamples`?
 - ✅ Check logs for "Twitter posting is ENABLED"
@@ -290,17 +341,11 @@ Your tokens may have been revoked or regenerated.
 
 ## 📚 Advanced Features
 
-### Timeline Algorithms
-
-**Weighted Algorithm** (default):
-- Combines user relationship, time, and relevance scores
-- Prioritizes tweets from important users
-- Balances recent content with relevant older content
+### Timeline Processing
 
-**Latest Algorithm**:
-- Processes tweets in chronological order
-- Simpler, more predictable behavior
-- Good for high-volume timelines
+The plugin supports two main approaches:
+- **Timeline Actions**: Process home timeline for likes, retweets, and quotes
+- **Targeted Interactions**: Reply to mentions and specific users
 
 ### Target User Configuration
 
@@ -317,14 +362,10 @@ TWITTER_TARGET_USERS=*
 
 ### Natural Posting Intervals
 
-All intervals support variance for more human-like behavior:
-```bash
-# Base interval: 90-180 minutes
-TWITTER_POST_INTERVAL_MIN=90
-TWITTER_POST_INTERVAL_MAX=180
-# With 20% variance: actual range ~72-216 minutes
-TWITTER_POST_INTERVAL_VARIANCE=0.2
-```
+The plugin adds variance to all intervals for more human-like behavior:
+- Post intervals vary by ±20% by default
+- Discovery intervals vary by ±10 minutes
+- Engagement intervals vary based on activity
 
 ### Request Queue & Rate Limiting
 

package/dist/index.d.ts

@@ -1,4 +1,5 @@
-import { IAgentRuntime, Memory, State, ChannelType, Plugin, Service, UUID } from '@elizaos/core';
+import * as _elizaos_core from '@elizaos/core';
+import { Service, IAgentRuntime, Memory, UUID, State, ChannelType } from '@elizaos/core';
 import * as twitter_api_v2 from 'twitter-api-v2';
 import { TwitterApi, PollV2, TTweetv2Expansion, TTweetv2TweetField, TTweetv2PollField, TTweetv2MediaField, TTweetv2UserField, TTweetv2PlaceField } from 'twitter-api-v2';
 
@@ -761,78 +762,14 @@ declare class Client {
     fetchQuotedTweetsPage(tweetId: string, maxQuotes?: number, cursor?: string): Promise<QueryTweetsResponse>;
 }
 
-/**
- * Class representing a client for interacting with Twitter.
- */
-declare class TwitterInteractionClient {
-    client: ClientBase;
-    runtime: IAgentRuntime;
-    private isDryRun;
-    private state;
-    /**
-     * Constructor for setting up a new instance with the provided client, runtime, and state.
-     * @param {ClientBase} client - The client being used for communication.
-     * @param {IAgentRuntime} runtime - The runtime environment for the agent.
-     * @param {any} state - The initial state of the agent.
-     */
-    constructor(client: ClientBase, runtime: IAgentRuntime, state: any);
-    /**
-     * Asynchronously starts the process of handling Twitter interactions on a loop.
-     * Uses an interval based on the 'TWITTER_POLL_INTERVAL' setting, or defaults to 2 minutes if not set.
-     */
-    start(): Promise<void>;
-    /**
-     * Asynchronously handles Twitter interactions by checking for mentions, processing tweets, and updating the last checked tweet ID.
-     */
-    handleTwitterInteractions(): Promise<void>;
-    /**
-     * Processes all incoming tweets that mention the bot.
-     * For each new tweet:
-     *  - Ensures world, room, and connection exist
-     *  - Saves the tweet as memory
-     *  - Emits thread-related events (THREAD_CREATED / THREAD_UPDATED)
-     *  - Delegates tweet content to `handleTweet` for reply generation
-     *
-     * Note: MENTION_RECEIVED is currently disabled (see TODO below)
-     */
-    processMentionTweets(mentionCandidates: Tweet$1[]): Promise<void>;
-    /**
-     * Handles Twitter interactions such as likes, retweets, and quotes.
-     * For each interaction:
-     *  - Creates a memory object
-     *  - Emits platform-specific events (LIKE_RECEIVED, RETWEET_RECEIVED, QUOTE_RECEIVED)
-     *  - Emits a generic REACTION_RECEIVED event with metadata
-     */
-    handleInteraction(interaction: TwitterInteractionPayload): Promise<void>;
-    /**
-     * Handles a tweet by processing its content, formatting it, generating image descriptions,
-     * saving the tweet if it doesn't already exist, determining if a response should be sent,
-     * composing a response prompt, generating a response based on the prompt, handling the response
-     * tweet, and saving information about the response.
-     *
-     * @param {object} params - The parameters object containing the tweet, message, and thread.
-     * @param {Tweet} params.tweet - The tweet object to handle.
-     * @param {Memory} params.message - The memory object associated with the tweet.
-     * @param {Tweet[]} params.thread - The array of tweets in the thread.
-     * @returns {object} - An object containing the text of the response and any relevant actions.
-     */
-    handleTweet({ tweet, message, thread, }: {
-        tweet: Tweet$1;
-        message: Memory;
-        thread: Tweet$1[];
-    }): Promise<{
-        text: string;
-        actions: string[];
-    }>;
-    /**
-     * Build a conversation thread based on a given tweet.
-     *
-     * @param {Tweet} tweet - The tweet to start the thread from.
-     * @param {number} [maxReplies=10] - The maximum number of replies to include in the thread.
-     * @returns {Promise<Tweet[]>} The conversation thread as an array of tweets.
-     */
-    buildConversationThread(tweet: Tweet$1, maxReplies?: number): Promise<Tweet$1[]>;
-    private createMemoryObject;
+declare class TwitterService extends Service {
+    static serviceType: string;
+    capabilityDescription: string;
+    private static instance;
+    constructor(runtime?: IAgentRuntime);
+    static getInstance(): TwitterService;
+    static start(runtime: IAgentRuntime): Promise<TwitterService>;
+    stop(): Promise<void>;
 }
 
 /**
@@ -844,6 +781,7 @@ declare class TwitterPostClient {
     twitterUsername: string;
     private isDryRun;
     private state;
+    private isRunning;
     /**
      * Constructor for initializing a new Twitter client with the provided client, runtime, and state
      * @param {ClientBase} client - The client used for interacting with Twitter API
@@ -851,6 +789,10 @@ declare class TwitterPostClient {
      * @param {any} state - The state object containing configuration settings
      */
     constructor(client: ClientBase, runtime: IAgentRuntime, state: any);
+    /**
+     * Stops the Twitter post client
+     */
+    stop(): Promise<void>;
     /**
      * Starts the Twitter post client, setting up a loop to periodically generate new tweets.
      */
@@ -867,7 +809,6 @@ declare class TwitterPostClient {
      * @returns {Promise<any>} The result from the Twitter API
      */
     private postToTwitter;
-    stop(): Promise<void>;
 }
 
 /**
@@ -906,6 +847,29 @@ type Tweet = {
     thread: any[];
     permanentUrl: string;
 };
+/**
+ * Twitter-specific memory interface
+ */
+interface TwitterMemory extends Memory {
+    content: {
+        source: "twitter";
+        text?: string;
+        type?: string;
+        targetId?: string;
+        [key: string]: any;
+    };
+    roomId: UUID;
+}
+/**
+ * Twitter-specific interaction memory
+ */
+interface TwitterInteractionMemory extends TwitterMemory {
+    content: {
+        type: string;
+        source: "twitter";
+        targetId?: string;
+    };
+}
 /**
  * Twitter-specific interaction payload
  */
@@ -943,6 +907,8 @@ type TwitterProfile = {
 declare class RequestQueue {
     private queue;
     private processing;
+    private maxRetries;
+    private retryAttempts;
     /**
      * Asynchronously adds a request to the queue, then processes the queue.
      *
@@ -1047,6 +1013,122 @@ declare class ClientBase {
     formatTweetToInteraction(tweet: any): TwitterInteractionPayload | null;
 }
 
+/**
+ * The TwitterInteractionClient class manages Twitter interactions,
+ * including handling mentions, managing timelines, and engaging with other users.
+ * It extends the base Twitter client functionality to provide mention handling,
+ * user interaction, and follow change detection capabilities.
+ *
+ * @extends ClientBase
+ */
+declare class TwitterInteractionClient {
+    client: ClientBase;
+    runtime: IAgentRuntime;
+    twitterUsername: string;
+    private twitterUserId;
+    private isDryRun;
+    private state;
+    private isRunning;
+    private lastProcessedTimestamp;
+    /**
+     * Constructor to initialize the Twitter interaction client with runtime and state management.
+     *
+     * @param {ClientBase} client - The client instance.
+     * @param {IAgentRuntime} runtime - The runtime instance for agent operations.
+     * @param {any} state - The state object containing configuration settings.
+     */
+    constructor(client: ClientBase, runtime: IAgentRuntime, state: any);
+    /**
+     * Asynchronously starts the process of handling Twitter interactions on a loop.
+     * Uses the unified TWITTER_ENGAGEMENT_INTERVAL setting.
+     */
+    start(): Promise<void>;
+    /**
+     * Stops the Twitter interaction client
+     */
+    stop(): Promise<void>;
+    /**
+     * Asynchronously handles Twitter interactions by checking for mentions and target user posts.
+     */
+    handleTwitterInteractions(): Promise<void>;
+    /**
+     * Handle mentions and replies
+     */
+    private handleMentions;
+    /**
+     * Handle autonomous engagement with target users' posts
+     */
+    private handleTargetUserPosts;
+    /**
+     * Process tweets from target users for potential engagement
+     */
+    private processTargetUserTweets;
+    /**
+     * Process timeline for engagement when wildcard is configured
+     */
+    private processTimelineForEngagement;
+    /**
+     * Determine if the bot should engage with a specific tweet
+     */
+    private shouldEngageWithTweet;
+    /**
+     * Ensure tweet context exists (world, room, entity)
+     */
+    private ensureTweetContext;
+    /**
+     * Engage with a tweet by generating and sending a reply
+     */
+    private engageWithTweet;
+    /**
+     * Processes all incoming tweets that mention the bot.
+     * For each new tweet:
+     *  - Ensures world, room, and connection exist
+     *  - Saves the tweet as memory
+     *  - Emits thread-related events (THREAD_CREATED / THREAD_UPDATED)
+     *  - Delegates tweet content to `handleTweet` for reply generation
+     *
+     * Note: MENTION_RECEIVED is currently disabled (see TODO below)
+     */
+    processMentionTweets(mentionCandidates: Tweet$1[]): Promise<void>;
+    /**
+     * Handles Twitter interactions such as likes, retweets, and quotes.
+     * For each interaction:
+     *  - Creates a memory object
+     *  - Emits platform-specific events (LIKE_RECEIVED, RETWEET_RECEIVED, QUOTE_RECEIVED)
+     *  - Emits a generic REACTION_RECEIVED event with metadata
+     */
+    handleInteraction(interaction: TwitterInteractionPayload): Promise<void>;
+    /**
+     * Creates a memory object for a given Twitter interaction.
+     *
+     * @param {string} type - The type of interaction (e.g., 'like', 'retweet', 'quote').
+     * @param {string} id - The unique identifier for the interaction.
+     * @param {string} userId - The ID of the user who initiated the interaction.
+     * @param {string} conversationId - The ID of the conversation context.
+     * @returns {TwitterInteractionMemory} The constructed memory object.
+     */
+    createMemoryObject(type: string, id: string, userId: string, conversationId: string): TwitterInteractionMemory;
+    /**
+     * Asynchronously handles a tweet by generating a response and sending it.
+     * This method processes the tweet content, determines if a response is needed,
+     * generates appropriate response text, and sends the tweet reply.
+     *
+     * @param {object} params - The parameters object containing the tweet, message, and thread.
+     * @param {Tweet} params.tweet - The tweet object to handle.
+     * @param {Memory} params.message - The memory object associated with the tweet.
+     * @param {Tweet[]} params.thread - The array of tweets in the thread.
+     * @returns {object} - An object containing the text of the response and any relevant actions.
+     */
+    handleTweet({ tweet, message, thread, }: {
+        tweet: Tweet$1;
+        message: Memory;
+        thread: Tweet$1[];
+    }): Promise<{
+        text: string;
+        actions: string[];
+    }>;
+}
+
 declare enum TIMELINE_TYPE {
     ForYou = "foryou",
     Following = "following"
@@ -1058,8 +1140,10 @@ declare class TwitterTimelineClient {
     isDryRun: boolean;
     timelineType: TIMELINE_TYPE;
     private state;
+    private isRunning;
     constructor(client: ClientBase, runtime: IAgentRuntime, state: any);
     start(): Promise<void>;
+    stop(): Promise<void>;
     getTimeline(count: number): Promise<Tweet$1[]>;
     createTweetId(runtime: IAgentRuntime, tweet: Tweet$1): `${string}-${string}-${string}-${string}-${string}`;
     formMessage(runtime: IAgentRuntime, tweet: Tweet$1): {
@@ -1087,48 +1171,59 @@ declare class TwitterTimelineClient {
     handleReplyAction(tweet: Tweet$1): Promise<void>;
 }
 
+declare class TwitterDiscoveryClient {
+    private client;
+    private twitterClient;
+    private runtime;
+    private config;
+    private isRunning;
+    private isDryRun;
+    constructor(client: ClientBase, runtime: IAgentRuntime, state: any);
+    private buildDiscoveryConfig;
+    private extractTopicsFromBio;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    private runDiscoveryCycle;
+    private discoverContent;
+    private discoverFromTopics;
+    private discoverFromThreads;
+    private discoverFromPopularAccounts;
+    private scoreTweet;
+    private scoreAccount;
+    private processAccounts;
+    private processTweets;
+    private checkIfFollowing;
+    private generateReply;
+    private generateQuote;
+    private saveEngagementMemory;
+    private saveFollowMemory;
+    private delay;
+}
+
 /**
  * A manager that orchestrates all specialized Twitter logic:
  * - client: base operations (login, timeline caching, etc.)
  * - post: autonomous posting logic
- * - search: searching tweets / replying logic
- * - interaction: handling mentions, replies
- * - space: launching and managing Twitter Spaces (optional)
- */
-/**
- * TwitterClientInstance class that implements ITwitterClient interface.
- *
- * @class
- * @implements {ITwitterClient}
+ * - interaction: handling mentions, replies, and autonomous targeting
+ * - timeline: processing timeline for actions (likes, retweets, replies)
+ * - discovery: autonomous content discovery and engagement
  */
 declare class TwitterClientInstance implements ITwitterClient {
     client: ClientBase;
     post: TwitterPostClient;
     interaction: TwitterInteractionClient;
     timeline?: TwitterTimelineClient;
+    discovery?: TwitterDiscoveryClient;
     service: TwitterService;
     constructor(runtime: IAgentRuntime, state: any);
 }
-declare class TwitterService extends Service {
-    static serviceType: string;
-    capabilityDescription: string;
-    private static instance;
-    private clients;
-    static getInstance(): TwitterService;
-    createClient(runtime: IAgentRuntime, clientId: string, state: any): Promise<TwitterClientInstance>;
-    /**
-     * Emits a standardized WORLD_JOINED event for Twitter
-     * @param runtime The agent runtime
-     * @param client The Twitter client instance
-     */
-    private emitServerJoinedEvent;
-    getClient(clientId: string, agentId: UUID): TwitterClientInstance | undefined;
-    stopClient(clientId: string, agentId: UUID): Promise<void>;
-    static start(runtime: IAgentRuntime): Promise<TwitterService>;
-    stop(): Promise<void>;
-    stopAllClients(): Promise<void>;
-    private getClientKey;
-}
-declare const twitterPlugin: Plugin;
+declare function startTwitterClient(runtime: IAgentRuntime): Promise<void>;
+declare const TwitterPlugin: {
+    name: string;
+    description: string;
+    actions: _elizaos_core.Action[];
+    services: (typeof TwitterService)[];
+    init: typeof startTwitterClient;
+};
 
-export { TwitterClientInstance, TwitterService, twitterPlugin as default };
+export { TwitterClientInstance, TwitterPlugin, TwitterPlugin as default };