feat: Batch 5-9 — GrowthIntegration桥接、验证补全、死代码清理、Pipeline模板、Speech/Twitter真实实现

Batch 5 (P0): GrowthIntegration 接入 Tauri
- Kernel 新增 set_viking()/set_extraction_driver() 桥接 SqliteStorage
- 中间件链共享存储，MemoryExtractor 接入 LLM 驱动

Batch 6 (P1): 输入验证 + Heartbeat
- Relay 验证补全（stream 兼容检查、API key 格式校验）
- UUID 类型校验、SessionId 错误返回
- Heartbeat 默认开启 + 首次聊天自动初始化

Batch 7 (P2): 死代码清理
- zclaw-channels 整体移除（317 行）
- multi-agent 特性门控、admin 方法标注

Batch 8 (P2): Pipeline 模板
- PipelineMetadata 新增 annotations 字段
- pipeline_templates 命令 + 2 个示例模板
- fallback driver base_url 修复（doubao/qwen/deepseek 端点）

Batch 9 (P1): SpeechHand/TwitterHand 真实实现
- SpeechHand: tts_method 字段 + Browser TTS 前端集成 (Web Speech API)
- TwitterHand: 12 个 action 全部替换为 Twitter API v2 真实 HTTP 调用
- chatStore/useAutomationEvents 双路径 TTS 触发

crates/zclaw-hands/src/hands/speech.rs

@@ -233,17 +233,32 @@ impl SpeechHand {
                 state.playback = PlaybackState::Playing;
                 state.current_text = Some(text.clone());
 
-                // In real implementation, would call TTS API
+                // Determine TTS method based on provider:
+                // - Browser: frontend uses Web Speech API (zero deps, works offline)
+                // - OpenAI: frontend calls speech_tts command (high-quality, needs API key)
+                // - Others: future support
+                let tts_method = match state.config.provider {
+                    TtsProvider::Browser => "browser",
+                    TtsProvider::OpenAI => "openai_api",
+                    TtsProvider::Azure => "azure_api",
+                    TtsProvider::ElevenLabs => "elevenlabs_api",
+                    TtsProvider::Local => "local_engine",
+                };
+
+                let estimated_duration_ms = (text.chars().count() as f64 / 5.0 * 1000.0) as u64;
+
                 Ok(HandResult::success(serde_json::json!({
                     "status": "speaking",
+                    "tts_method": tts_method,
                     "text": text,
                     "voice": voice_id,
                     "language": lang,
                     "rate": actual_rate,
                     "pitch": actual_pitch,
                     "volume": actual_volume,
-                    "provider": state.config.provider,
-                    "duration_ms": text.len() as u64 * 80, // Rough estimate
+                    "provider": format!("{:?}", state.config.provider).to_lowercase(),
+                    "duration_ms": estimated_duration_ms,
+                    "instruction": "Frontend should play this via TTS engine"
                 })))
             }
             SpeechAction::SpeakSsml { ssml, voice } => {

crates/zclaw-hands/src/hands/twitter.rs

@@ -289,117 +289,435 @@ impl TwitterHand {
         c.clone()
     }
 
-    /// Execute tweet action
+    /// Execute tweet action — POST /2/tweets
     async fn execute_tweet(&self, config: &TweetConfig) -> Result<Value> {
-        let _creds = self.get_credentials().await
+        let creds = self.get_credentials().await
             .ok_or_else(|| zclaw_types::ZclawError::HandError("Twitter credentials not configured".to_string()))?;
 
-        // Simulated tweet response (actual implementation would use Twitter API)
-        // In production, this would call Twitter API v2: POST /2/tweets
+        let client = reqwest::Client::new();
+        let body = json!({ "text": config.text });
+
+        let response = client.post("https://api.twitter.com/2/tweets")
+            .header("Authorization", format!("Bearer {}", creds.bearer_token.as_deref().unwrap_or("")))
+            .header("Content-Type", "application/json")
+            .header("User-Agent", "ZCLAW/1.0")
+            .json(&body)
+            .send()
+            .await
+            .map_err(|e| zclaw_types::ZclawError::HandError(format!("Twitter API request failed: {}", e)))?;
+
+        let status = response.status();
+        let response_text = response.text().await
+            .map_err(|e| zclaw_types::ZclawError::HandError(format!("Failed to read response: {}", e)))?;
+
+        if !status.is_success() {
+            tracing::warn!("[TwitterHand] Tweet failed: {} - {}", status, response_text);
+            return Ok(json!({
+                "success": false,
+                "error": format!("Twitter API returned {}: {}", status, response_text),
+                "status_code": status.as_u16()
+            }));
+        }
+
+        // Parse the response to extract tweet_id
+        let parsed: Value = serde_json::from_str(&response_text).unwrap_or(json!({"raw": response_text}));
+
         Ok(json!({
             "success": true,
-            "tweet_id": format!("simulated_{}", chrono::Utc::now().timestamp()),
+            "tweet_id": parsed["data"]["id"].as_str().unwrap_or("unknown"),
             "text": config.text,
-            "created_at": chrono::Utc::now().to_rfc3339(),
-            "message": "Tweet posted successfully (simulated)",
-            "note": "Connect Twitter API credentials for actual posting"
+            "raw_response": parsed,
+            "message": "Tweet posted successfully"
         }))
     }
 
-    /// Execute search action
+    /// Execute search action — GET /2/tweets/search/recent
     async fn execute_search(&self, config: &SearchConfig) -> Result<Value> {
-        let _creds = self.get_credentials().await
+        let creds = self.get_credentials().await
             .ok_or_else(|| zclaw_types::ZclawError::HandError("Twitter credentials not configured".to_string()))?;
 
-        // Simulated search response
-        // In production, this would call Twitter API v2: GET /2/tweets/search/recent
+        let client = reqwest::Client::new();
+        let max = config.max_results.max(10).min(100);
+
+        let response = client.get("https://api.twitter.com/2/tweets/search/recent")
+            .header("Authorization", format!("Bearer {}", creds.bearer_token.as_deref().unwrap_or("")))
+            .header("User-Agent", "ZCLAW/1.0")
+            .query(&[
+                ("query", config.query.as_str()),
+                ("max_results", max.to_string().as_str()),
+                ("tweet.fields", "created_at,author_id,public_metrics,lang"),
+            ])
+            .send()
+            .await
+            .map_err(|e| zclaw_types::ZclawError::HandError(format!("Twitter search failed: {}", e)))?;
+
+        let status = response.status();
+        let response_text = response.text().await
+            .map_err(|e| zclaw_types::ZclawError::HandError(format!("Failed to read response: {}", e)))?;
+
+        if !status.is_success() {
+            return Ok(json!({
+                "success": false,
+                "error": format!("Twitter API returned {}: {}", status, response_text),
+                "status_code": status.as_u16()
+            }));
+        }
+
+        let parsed: Value = serde_json::from_str(&response_text).unwrap_or(json!({"raw": response_text}));
+
         Ok(json!({
             "success": true,
             "query": config.query,
-            "tweets": [],
-            "meta": {
-                "result_count": 0,
-                "newest_id": null,
-                "oldest_id": null,
-                "next_token": null
-            },
-            "message": "Search completed (simulated - no actual results without API)",
-            "note": "Connect Twitter API credentials for actual search results"
+            "tweets": parsed["data"].as_array().cloned().unwrap_or_default(),
+            "meta": parsed["meta"].clone(),
+            "message": "Search completed"
         }))
     }
 
-    /// Execute timeline action
+    /// Execute timeline action — GET /2/users/:id/timelines/reverse_chronological
     async fn execute_timeline(&self, config: &TimelineConfig) -> Result<Value> {
-        let _creds = self.get_credentials().await
+        let creds = self.get_credentials().await
             .ok_or_else(|| zclaw_types::ZclawError::HandError("Twitter credentials not configured".to_string()))?;
 
-        // Simulated timeline response
+        let client = reqwest::Client::new();
+        let user_id = config.user_id.as_deref().unwrap_or("me");
+        let url = format!("https://api.twitter.com/2/users/{}/timelines/reverse_chronological", user_id);
+        let max = config.max_results.max(5).min(100);
+
+        let response = client.get(&url)
+            .header("Authorization", format!("Bearer {}", creds.bearer_token.as_deref().unwrap_or("")))
+            .header("User-Agent", "ZCLAW/1.0")
+            .query(&[
+                ("max_results", max.to_string().as_str()),
+                ("tweet.fields", "created_at,author_id,public_metrics"),
+            ])
+            .send()
+            .await
+            .map_err(|e| zclaw_types::ZclawError::HandError(format!("Timeline fetch failed: {}", e)))?;
+
+        let status = response.status();
+        let response_text = response.text().await
+            .map_err(|e| zclaw_types::ZclawError::HandError(format!("Failed to read response: {}", e)))?;
+
+        if !status.is_success() {
+            return Ok(json!({
+                "success": false,
+                "error": format!("Twitter API returned {}: {}", status, response_text),
+                "status_code": status.as_u16()
+            }));
+        }
+
+        let parsed: Value = serde_json::from_str(&response_text).unwrap_or(json!({"raw": response_text}));
+
         Ok(json!({
             "success": true,
-            "user_id": config.user_id,
-            "tweets": [],
-            "meta": {
-                "result_count": 0,
-                "newest_id": null,
-                "oldest_id": null,
-                "next_token": null
-            },
-            "message": "Timeline fetched (simulated)",
-            "note": "Connect Twitter API credentials for actual timeline"
+            "user_id": user_id,
+            "tweets": parsed["data"].as_array().cloned().unwrap_or_default(),
+            "meta": parsed["meta"].clone(),
+            "message": "Timeline fetched"
         }))
     }
 
-    /// Get tweet by ID
+    /// Get tweet by ID — GET /2/tweets/:id
     async fn execute_get_tweet(&self, tweet_id: &str) -> Result<Value> {
-        let _creds = self.get_credentials().await
+        let creds = self.get_credentials().await
             .ok_or_else(|| zclaw_types::ZclawError::HandError("Twitter credentials not configured".to_string()))?;
 
+        let client = reqwest::Client::new();
+        let url = format!("https://api.twitter.com/2/tweets/{}", tweet_id);
+
+        let response = client.get(&url)
+            .header("Authorization", format!("Bearer {}", creds.bearer_token.as_deref().unwrap_or("")))
+            .header("User-Agent", "ZCLAW/1.0")
+            .query(&[("tweet.fields", "created_at,author_id,public_metrics,lang")])
+            .send()
+            .await
+            .map_err(|e| zclaw_types::ZclawError::HandError(format!("Tweet lookup failed: {}", e)))?;
+
+        let status = response.status();
+        let response_text = response.text().await
+            .map_err(|e| zclaw_types::ZclawError::HandError(format!("Failed to read response: {}", e)))?;
+
+        if !status.is_success() {
+            return Ok(json!({
+                "success": false,
+                "error": format!("Twitter API returned {}: {}", status, response_text),
+                "status_code": status.as_u16()
+            }));
+        }
+
+        let parsed: Value = serde_json::from_str(&response_text).unwrap_or(json!({"raw": response_text}));
+
         Ok(json!({
             "success": true,
             "tweet_id": tweet_id,
-            "tweet": null,
-            "message": "Tweet lookup (simulated)",
-            "note": "Connect Twitter API credentials for actual tweet data"
+            "tweet": parsed["data"].clone(),
+            "message": "Tweet fetched"
         }))
     }
 
-    /// Get user by username
+    /// Get user by username — GET /2/users/by/username/:username
     async fn execute_get_user(&self, username: &str) -> Result<Value> {
-        let _creds = self.get_credentials().await
+        let creds = self.get_credentials().await
             .ok_or_else(|| zclaw_types::ZclawError::HandError("Twitter credentials not configured".to_string()))?;
 
+        let client = reqwest::Client::new();
+        let url = format!("https://api.twitter.com/2/users/by/username/{}", username);
+
+        let response = client.get(&url)
+            .header("Authorization", format!("Bearer {}", creds.bearer_token.as_deref().unwrap_or("")))
+            .header("User-Agent", "ZCLAW/1.0")
+            .query(&[("user.fields", "created_at,description,public_metrics,verified")])
+            .send()
+            .await
+            .map_err(|e| zclaw_types::ZclawError::HandError(format!("User lookup failed: {}", e)))?;
+
+        let status = response.status();
+        let response_text = response.text().await
+            .map_err(|e| zclaw_types::ZclawError::HandError(format!("Failed to read response: {}", e)))?;
+
+        if !status.is_success() {
+            return Ok(json!({
+                "success": false,
+                "error": format!("Twitter API returned {}: {}", status, response_text),
+                "status_code": status.as_u16()
+            }));
+        }
+
+        let parsed: Value = serde_json::from_str(&response_text).unwrap_or(json!({"raw": response_text}));
+
         Ok(json!({
             "success": true,
             "username": username,
-            "user": null,
-            "message": "User lookup (simulated)",
-            "note": "Connect Twitter API credentials for actual user data"
+            "user": parsed["data"].clone(),
+            "message": "User fetched"
         }))
     }
 
-    /// Execute like action
+    /// Execute like action — PUT /2/users/:id/likes
     async fn execute_like(&self, tweet_id: &str) -> Result<Value> {
-        let _creds = self.get_credentials().await
+        let creds = self.get_credentials().await
             .ok_or_else(|| zclaw_types::ZclawError::HandError("Twitter credentials not configured".to_string()))?;
 
+        let client = reqwest::Client::new();
+        // Note: For like/retweet, we need OAuth 1.0a user context
+        // Using Bearer token as fallback (may not work for all endpoints)
+        let url = "https://api.twitter.com/2/users/me/likes";
+
+        let response = client.post(url)
+            .header("Authorization", format!("Bearer {}", creds.bearer_token.as_deref().unwrap_or("")))
+            .header("Content-Type", "application/json")
+            .header("User-Agent", "ZCLAW/1.0")
+            .json(&json!({"tweet_id": tweet_id}))
+            .send()
+            .await
+            .map_err(|e| zclaw_types::ZclawError::HandError(format!("Like failed: {}", e)))?;
+
+        let status = response.status();
+        let response_text = response.text().await.unwrap_or_default();
+
         Ok(json!({
-            "success": true,
+            "success": status.is_success(),
             "tweet_id": tweet_id,
             "action": "liked",
-            "message": "Tweet liked (simulated)"
+            "status_code": status.as_u16(),
+            "message": if status.is_success() { "Tweet liked" } else { &response_text }
         }))
     }
 
-    /// Execute retweet action
+    /// Execute retweet action — POST /2/users/:id/retweets
     async fn execute_retweet(&self, tweet_id: &str) -> Result<Value> {
-        let _creds = self.get_credentials().await
+        let creds = self.get_credentials().await
             .ok_or_else(|| zclaw_types::ZclawError::HandError("Twitter credentials not configured".to_string()))?;
 
+        let client = reqwest::Client::new();
+        let url = "https://api.twitter.com/2/users/me/retweets";
+
+        let response = client.post(url)
+            .header("Authorization", format!("Bearer {}", creds.bearer_token.as_deref().unwrap_or("")))
+            .header("Content-Type", "application/json")
+            .header("User-Agent", "ZCLAW/1.0")
+            .json(&json!({"tweet_id": tweet_id}))
+            .send()
+            .await
+            .map_err(|e| zclaw_types::ZclawError::HandError(format!("Retweet failed: {}", e)))?;
+
+        let status = response.status();
+        let response_text = response.text().await.unwrap_or_default();
+
+        Ok(json!({
+            "success": status.is_success(),
+            "tweet_id": tweet_id,
+            "action": "retweeted",
+            "status_code": status.as_u16(),
+            "message": if status.is_success() { "Tweet retweeted" } else { &response_text }
+        }))
+    }
+
+    /// Execute delete tweet — DELETE /2/tweets/:id
+    async fn execute_delete_tweet(&self, tweet_id: &str) -> Result<Value> {
+        let creds = self.get_credentials().await
+            .ok_or_else(|| zclaw_types::ZclawError::HandError("Twitter credentials not configured".to_string()))?;
+
+        let client = reqwest::Client::new();
+        let url = format!("https://api.twitter.com/2/tweets/{}", tweet_id);
+
+        let response = client.delete(&url)
+            .header("Authorization", format!("Bearer {}", creds.bearer_token.as_deref().unwrap_or("")))
+            .header("User-Agent", "ZCLAW/1.0")
+            .send()
+            .await
+            .map_err(|e| zclaw_types::ZclawError::HandError(format!("Delete tweet failed: {}", e)))?;
+
+        let status = response.status();
+        let response_text = response.text().await.unwrap_or_default();
+
+        Ok(json!({
+            "success": status.is_success(),
+            "tweet_id": tweet_id,
+            "action": "deleted",
+            "status_code": status.as_u16(),
+            "message": if status.is_success() { "Tweet deleted" } else { &response_text }
+        }))
+    }
+
+    /// Execute unretweet — DELETE /2/users/:id/retweets/:tweet_id
+    async fn execute_unretweet(&self, tweet_id: &str) -> Result<Value> {
+        let creds = self.get_credentials().await
+            .ok_or_else(|| zclaw_types::ZclawError::HandError("Twitter credentials not configured".to_string()))?;
+
+        let client = reqwest::Client::new();
+        let url = format!("https://api.twitter.com/2/users/me/retweets/{}", tweet_id);
+
+        let response = client.delete(&url)
+            .header("Authorization", format!("Bearer {}", creds.bearer_token.as_deref().unwrap_or("")))
+            .header("User-Agent", "ZCLAW/1.0")
+            .send()
+            .await
+            .map_err(|e| zclaw_types::ZclawError::HandError(format!("Unretweet failed: {}", e)))?;
+
+        let status = response.status();
+        let response_text = response.text().await.unwrap_or_default();
+
+        Ok(json!({
+            "success": status.is_success(),
+            "tweet_id": tweet_id,
+            "action": "unretweeted",
+            "status_code": status.as_u16(),
+            "message": if status.is_success() { "Tweet unretweeted" } else { &response_text }
+        }))
+    }
+
+    /// Execute unlike — DELETE /2/users/:id/likes/:tweet_id
+    async fn execute_unlike(&self, tweet_id: &str) -> Result<Value> {
+        let creds = self.get_credentials().await
+            .ok_or_else(|| zclaw_types::ZclawError::HandError("Twitter credentials not configured".to_string()))?;
+
+        let client = reqwest::Client::new();
+        let url = format!("https://api.twitter.com/2/users/me/likes/{}", tweet_id);
+
+        let response = client.delete(&url)
+            .header("Authorization", format!("Bearer {}", creds.bearer_token.as_deref().unwrap_or("")))
+            .header("User-Agent", "ZCLAW/1.0")
+            .send()
+            .await
+            .map_err(|e| zclaw_types::ZclawError::HandError(format!("Unlike failed: {}", e)))?;
+
+        let status = response.status();
+        let response_text = response.text().await.unwrap_or_default();
+
+        Ok(json!({
+            "success": status.is_success(),
+            "tweet_id": tweet_id,
+            "action": "unliked",
+            "status_code": status.as_u16(),
+            "message": if status.is_success() { "Tweet unliked" } else { &response_text }
+        }))
+    }
+
+    /// Execute followers fetch — GET /2/users/:id/followers
+    async fn execute_followers(&self, user_id: &str, max_results: Option<u32>) -> Result<Value> {
+        let creds = self.get_credentials().await
+            .ok_or_else(|| zclaw_types::ZclawError::HandError("Twitter credentials not configured".to_string()))?;
+
+        let client = reqwest::Client::new();
+        let url = format!("https://api.twitter.com/2/users/{}/followers", user_id);
+        let max = max_results.unwrap_or(100).max(1).min(1000);
+
+        let response = client.get(&url)
+            .header("Authorization", format!("Bearer {}", creds.bearer_token.as_deref().unwrap_or("")))
+            .header("User-Agent", "ZCLAW/1.0")
+            .query(&[
+                ("max_results", max.to_string()),
+                ("user.fields", "created_at,description,public_metrics,verified,profile_image_url".to_string()),
+            ])
+            .send()
+            .await
+            .map_err(|e| zclaw_types::ZclawError::HandError(format!("Followers fetch failed: {}", e)))?;
+
+        let status = response.status();
+        let response_text = response.text().await
+            .map_err(|e| zclaw_types::ZclawError::HandError(format!("Failed to read response: {}", e)))?;
+
+        if !status.is_success() {
+            return Ok(json!({
+                "success": false,
+                "error": format!("Twitter API returned {}: {}", status, response_text),
+                "status_code": status.as_u16()
+            }));
+        }
+
+        let parsed: Value = serde_json::from_str(&response_text).unwrap_or(json!({"raw": response_text}));
+
         Ok(json!({
             "success": true,
-            "tweet_id": tweet_id,
-            "action": "retweeted",
-            "message": "Tweet retweeted (simulated)"
+            "user_id": user_id,
+            "followers": parsed["data"].as_array().cloned().unwrap_or_default(),
+            "meta": parsed["meta"].clone(),
+            "message": "Followers fetched"
+        }))
+    }
+
+    /// Execute following fetch — GET /2/users/:id/following
+    async fn execute_following(&self, user_id: &str, max_results: Option<u32>) -> Result<Value> {
+        let creds = self.get_credentials().await
+            .ok_or_else(|| zclaw_types::ZclawError::HandError("Twitter credentials not configured".to_string()))?;
+
+        let client = reqwest::Client::new();
+        let url = format!("https://api.twitter.com/2/users/{}/following", user_id);
+        let max = max_results.unwrap_or(100).max(1).min(1000);
+
+        let response = client.get(&url)
+            .header("Authorization", format!("Bearer {}", creds.bearer_token.as_deref().unwrap_or("")))
+            .header("User-Agent", "ZCLAW/1.0")
+            .query(&[
+                ("max_results", max.to_string()),
+                ("user.fields", "created_at,description,public_metrics,verified,profile_image_url".to_string()),
+            ])
+            .send()
+            .await
+            .map_err(|e| zclaw_types::ZclawError::HandError(format!("Following fetch failed: {}", e)))?;
+
+        let status = response.status();
+        let response_text = response.text().await
+            .map_err(|e| zclaw_types::ZclawError::HandError(format!("Failed to read response: {}", e)))?;
+
+        if !status.is_success() {
+            return Ok(json!({
+                "success": false,
+                "error": format!("Twitter API returned {}: {}", status, response_text),
+                "status_code": status.as_u16()
+            }));
+        }
+
+        let parsed: Value = serde_json::from_str(&response_text).unwrap_or(json!({"raw": response_text}));
+
+        Ok(json!({
+            "success": true,
+            "user_id": user_id,
+            "following": parsed["data"].as_array().cloned().unwrap_or_default(),
+            "meta": parsed["meta"].clone(),
+            "message": "Following fetched"
         }))
     }
 
@@ -461,54 +779,17 @@ impl Hand for TwitterHand {
 
         let result = match action {
             TwitterAction::Tweet { config } => self.execute_tweet(&config).await?,
-            TwitterAction::DeleteTweet { tweet_id } => {
-                json!({
-                    "success": true,
-                    "tweet_id": tweet_id,
-                    "action": "deleted",
-                    "message": "Tweet deleted (simulated)"
-                })
-            }
+            TwitterAction::DeleteTweet { tweet_id } => self.execute_delete_tweet(&tweet_id).await?,
             TwitterAction::Retweet { tweet_id } => self.execute_retweet(&tweet_id).await?,
-            TwitterAction::Unretweet { tweet_id } => {
-                json!({
-                    "success": true,
-                    "tweet_id": tweet_id,
-                    "action": "unretweeted",
-                    "message": "Tweet unretweeted (simulated)"
-                })
-            }
+            TwitterAction::Unretweet { tweet_id } => self.execute_unretweet(&tweet_id).await?,
             TwitterAction::Like { tweet_id } => self.execute_like(&tweet_id).await?,
-            TwitterAction::Unlike { tweet_id } => {
-                json!({
-                    "success": true,
-                    "tweet_id": tweet_id,
-                    "action": "unliked",
-                    "message": "Tweet unliked (simulated)"
-                })
-            }
+            TwitterAction::Unlike { tweet_id } => self.execute_unlike(&tweet_id).await?,
             TwitterAction::Search { config } => self.execute_search(&config).await?,
             TwitterAction::Timeline { config } => self.execute_timeline(&config).await?,
             TwitterAction::GetTweet { tweet_id } => self.execute_get_tweet(&tweet_id).await?,
             TwitterAction::GetUser { username } => self.execute_get_user(&username).await?,
-            TwitterAction::Followers { user_id, max_results } => {
-                json!({
-                    "success": true,
-                    "user_id": user_id,
-                    "followers": [],
-                    "max_results": max_results.unwrap_or(100),
-                    "message": "Followers fetched (simulated)"
-                })
-            }
-            TwitterAction::Following { user_id, max_results } => {
-                json!({
-                    "success": true,
-                    "user_id": user_id,
-                    "following": [],
-                    "max_results": max_results.unwrap_or(100),
-                    "message": "Following fetched (simulated)"
-                })
-            }
+            TwitterAction::Followers { user_id, max_results } => self.execute_followers(&user_id, max_results).await?,
+            TwitterAction::Following { user_id, max_results } => self.execute_following(&user_id, max_results).await?,
             TwitterAction::CheckCredentials => self.execute_check_credentials().await?,
         };