vibesurf 0.1.25__py3-none-any.whl → 0.1.27__py3-none-any.whl

vibe_surf/tools/vibesurf_tools.py

@@ -31,7 +31,8 @@ from browser_use.tools.views import NoParamsAction
 from vibe_surf.browser.agent_browser_session import AgentBrowserSession
 from vibe_surf.tools.views import HoverAction, ExtractionAction, FileExtractionAction, BrowserUseAgentExecution, \
     ReportWriterTask, TodoGenerateAction, TodoModifyAction, VibeSurfDoneAction, SkillSearchAction, SkillCrawlAction, \
-    SkillSummaryAction, SkillTakeScreenshotAction, SkillDeepResearchAction, SkillCodeAction, SkillFinanceAction
+    SkillSummaryAction, SkillTakeScreenshotAction, SkillDeepResearchAction, SkillCodeAction, SkillFinanceAction, \
+    SkillXhsAction, SkillDouyinAction, SkillYoutubeAction, SkillWeiboAction
 from vibe_surf.tools.finance_tools import FinanceDataRetriever, FinanceMarkdownFormatter, FinanceMethod
 from vibe_surf.tools.mcp_client import CustomMCPClient
 from vibe_surf.tools.file_system import CustomFileSystem
@@ -231,7 +232,9 @@ Example format: ["query 1", "query 2", "query 3", "query 4", "query 5", "query 6
                     # Fallback to simple queries if parsing fails
                     try:
                         from json_repair import repair_json
-                        search_queries = repair_json(response.completion.strip())
+                        search_queries_s = repair_json(response.completion.strip())
+                        search_queries = json.loads(search_queries_s)
+                        search_queries = search_queries[:query_num]
                     except Exception as e:
                         search_queries = [
                             params.query,
@@ -244,7 +247,7 @@ Example format: ["query 1", "query 2", "query 3", "query 4", "query 5", "query 6
                 # Step 2: Create browser sessions for parallel searching
                 register_sessions = []
 
-                for i, query in enumerate(search_queries):
+                for i, query in enumerate(search_queries[:query_num]):
                     agent_id = f"search_agent_{i + 1:03d}"
                     register_sessions.append(
                         browser_manager.register_agent(agent_id, target_id=None)
@@ -278,41 +281,59 @@ Example format: ["query 1", "query 2", "query 3", "query 4", "query 5", "query 6
                 # Step 5: Use LLM only for final ranking and selection (much smaller dataset now)
                 if all_results and len(all_results) > 10:
                     # Only use LLM if we have more than 10 results to rank
+                    # Create indexed results for LLM prompt
+                    indexed_results = []
+                    for i, result in enumerate(all_results):
+                        indexed_results.append({
+                            "index": i,
+                            "title": result.get('title', 'Unknown Title'),
+                            "url": result.get('url', 'No URL'),
+                            "summary": result.get('summary', 'No summary available')
+                        })
+                    
                     ranking_prompt = f"""
 Rank these search results for the query "{params.query}" by relevance and value.
 Select the TOP 10 most relevant and valuable results.
 
-Search Results ({len(all_results)} total):
-{json.dumps(all_results, indent=2)}
+Search Results ({len(indexed_results)} total):
+{json.dumps(indexed_results, indent=2, ensure_ascii=False)}
 
-Return the top 10 results as a JSON array with each result containing:
-- title: string
-- url: string
-- summary: string (brief description of why this result is valuable)
+Return ONLY the indices of the top 10 results as a JSON array of numbers.
+For example: [0, 5, 2, 8, 1, 9, 3, 7, 4, 6]
 
-Format: [{{"title": "...", "url": "...", "summary": "..."}}, ...]
+Format: [index1, index2, index3, ...]
 """
 
                     ranking_response = await llm.ainvoke([
                         SystemMessage(
-                            content="You are an expert at ranking search results for relevance and value."),
+                            content="You are an expert at ranking search results for relevance and value. Return only the indices of the top results."),
                         UserMessage(content=ranking_prompt)
                     ])
 
                     try:
-                        top_results = json.loads(ranking_response.completion.strip())
-                        if not isinstance(top_results, list):
+                        selected_indices = json.loads(ranking_response.completion.strip())
+                        if not isinstance(selected_indices, list):
                             raise ValueError("Invalid ranking results format")
-                        top_results = top_results[:10]  # Ensure max 10 results
+                        # Ensure indices are valid and limit to 10
+                        valid_indices = [i for i in selected_indices if isinstance(i, int) and 0 <= i < len(all_results)][:10]
+                        if valid_indices:
+                            top_results = [all_results[i] for i in valid_indices]
+                        else:
+                            top_results = all_results[:10]
                     except (json.JSONDecodeError, ValueError):
                         try:
-                            top_results = repair_json(ranking_response.completion.strip())
-                            if isinstance(top_results, list):
-                                top_results = top_results[:10]
+                            selected_indices_s = repair_json(ranking_response.completion.strip())
+                            selected_indices = json.loads(selected_indices_s)
+                            if isinstance(selected_indices, list):
+                                valid_indices = [i for i in selected_indices if isinstance(i, int) and 0 <= i < len(all_results)][:10]
+                                if valid_indices:
+                                    top_results = [all_results[i] for i in valid_indices]
+                                else:
+                                    top_results = all_results[:10]
                             else:
                                 top_results = all_results[:10]
                         except Exception:
-                            # Fallback to first 10 deduplicated results
+                            # Fallback to first 10 results
                             top_results = all_results[:10]
                 elif all_results:
                     # If we have 10 or fewer results, skip LLM ranking
@@ -496,7 +517,7 @@ Format: [{{"title": "...", "url": "...", "summary": "..."}}, ...]
                 with open(filepath, "wb") as f:
                     f.write(base64.b64decode(screenshot))
 
-                msg = f'📸 Screenshot saved to path: {str(filepath.relative_to(fs_dir))}'
+                msg = f'📸 Screenshot saved to path: [{filename}]({str(filepath.relative_to(fs_dir))})'
                 logger.info(msg)
                 return ActionResult(
                     extracted_content=msg,
@@ -922,7 +943,428 @@ Please generate alternative JavaScript code that avoids this system error:"""
             except Exception as e:
                 error_msg = f'❌ Failed to retrieve financial data for {params.symbol}: {str(e)}'
                 logger.error(error_msg)
-                return ActionResult(error=error_msg)
+                return ActionResult(error=error_msg, extracted_content=error_msg)
+
+
+        @self.registry.action(
+            'Skill: Xiaohongshu API - Access Xiaohongshu (Little Red Book) platform data including search, content details, comments, user profiles, and recommendations. Methods: search_content_by_keyword, fetch_content_details, fetch_all_content_comments, get_user_profile, fetch_all_user_content, get_home_recommendations.',
+            param_model=SkillXhsAction,
+        )
+        async def skill_xhs(
+                params: SkillXhsAction,
+                browser_manager: BrowserManager,
+                file_system: CustomFileSystem
+        ):
+            """
+            Skill: Xiaohongshu API integration
+            
+            Available methods:
+            - search_content_by_keyword: Search content by keyword with sorting options
+            - fetch_content_details: Get detailed information about specific content
+            - fetch_all_content_comments: Get all comments for specific content
+            - get_user_profile: Get user profile information
+            - fetch_all_user_content: Get all content posted by a user
+            - get_home_recommendations: Get homepage recommended content
+            """
+            try:
+                from vibe_surf.tools.website_api.xhs.client import XiaoHongShuApiClient
+                
+                # Initialize client
+                xhs_client = XiaoHongShuApiClient(browser_session=browser_manager.main_browser_session)
+                await xhs_client.setup()
+                
+                # Parse params JSON string
+                import json
+                from json_repair import repair_json
+                try:
+                    method_params = json.loads(params.params)
+                except json.JSONDecodeError:
+                    method_params = json.loads(repair_json(params.params))
+                
+                # Execute the requested method
+                result = None
+                if params.method == "search_content_by_keyword":
+                    result = await xhs_client.search_content_by_keyword(**method_params)
+                elif params.method == "fetch_content_details":
+                    result = await xhs_client.fetch_content_details(**method_params)
+                elif params.method == "fetch_all_content_comments":
+                    result = await xhs_client.fetch_all_content_comments(**method_params)
+                elif params.method == "get_user_profile":
+                    result = await xhs_client.get_user_profile(**method_params)
+                elif params.method == "fetch_all_user_content":
+                    result = await xhs_client.fetch_all_user_content(**method_params)
+                elif params.method == "get_home_recommendations":
+                    result = await xhs_client.get_home_recommendations()
+                else:
+                    return ActionResult(error=f"Unknown method: {params.method}")
+                
+                # Save result to file
+                timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+                filename = f"xhs_{params.method}_{timestamp}.json"
+                filepath = file_system.get_dir() / "data" / filename
+                filepath.parent.mkdir(exist_ok=True)
+                
+                with open(filepath, "w", encoding="utf-8") as f:
+                    json.dump(result, f, ensure_ascii=False, indent=2)
+                
+                # Format result as markdown
+                if isinstance(result, list):
+                    display_count = min(5, len(result))
+                    md_content = f"## Xiaohongshu {params.method.replace('_', ' ').title()}\n\n"
+                    md_content += f"Showing {display_count} of {len(result)} results:\n\n"
+                    for i, item in enumerate(result[:display_count]):
+                        md_content += f"### Result {i+1}\n"
+                        for key, value in item.items():
+                            if not value:
+                                continue
+                            if isinstance(value, str) and len(value) > 200:
+                                md_content += f"- **{key}**: {value[:200]}...\n"
+                            else:
+                                md_content += f"- **{key}**: {value}\n"
+                        md_content += "\n"
+                else:
+                    md_content = f"## Xiaohongshu {params.method.replace('_', ' ').title()}\n\n"
+                    for key, value in result.items():
+                        if isinstance(value, str) and len(value) > 200:
+                            md_content += f"- **{key}**: {value[:200]}...\n"
+                        else:
+                            md_content += f"- **{key}**: {value}\n"
+                    md_content += "\n"
+                
+                # Add file path to markdown
+                relative_path = str(filepath.relative_to(file_system.get_dir()))
+                md_content += f"\n> 📁 Full data saved to: [{filename}]({relative_path})\n"
+                md_content += f"> 💡 Click the link above to view all results.\n"
+                
+                logger.info(f'📕 Xiaohongshu data retrieved with method: {params.method}')
+                
+                # Close client
+                await xhs_client.close()
+                
+                return ActionResult(
+                    extracted_content=md_content
+                )
+                
+            except Exception as e:
+                error_msg = f'❌ Failed to retrieve Xiaohongshu data: {str(e)}'
+                logger.error(error_msg)
+                return ActionResult(error=error_msg, extracted_content=error_msg)
+
+
+        @self.registry.action(
+            'Skill: Weibo API - Access Weibo platform data including search, post details, comments, user profiles, hot posts, and trending lists. Methods: search_posts_by_keyword, get_post_detail, get_all_post_comments, get_user_info, get_all_user_posts, get_hot_posts（推荐榜）, get_trending_posts(热搜榜）.',
+            param_model=SkillWeiboAction,
+        )
+        async def skill_weibo(
+                params: SkillWeiboAction,
+                browser_manager: BrowserManager,
+                file_system: CustomFileSystem
+        ):
+            """
+            Skill: Weibo API integration
+            
+            Available methods:
+            - search_posts_by_keyword: Search posts by keyword with sorting options
+            - get_post_detail: Get detailed information about specific post
+            - get_all_post_comments: Get all comments for specific post
+            - get_user_info: Get user profile information
+            - get_all_user_posts: Get all posts by a user
+            - get_hot_posts: Get hot posts
+            - get_trending_list: Get trending list
+            """
+            try:
+                from vibe_surf.tools.website_api.weibo.client import WeiboApiClient
+                
+                # Initialize client
+                wb_client = WeiboApiClient(browser_session=browser_manager.main_browser_session)
+                await wb_client.setup()
+                
+                # Parse params JSON string
+                import json
+                from json_repair import repair_json
+                try:
+                    method_params = json.loads(params.params)
+                except json.JSONDecodeError:
+                    method_params = json.loads(repair_json(params.params))
+                
+                # Execute the requested method
+                result = None
+                if params.method == "search_posts_by_keyword":
+                    result = await wb_client.search_posts_by_keyword(**method_params)
+                elif params.method == "get_post_detail":
+                    result = await wb_client.get_post_detail(**method_params)
+                elif params.method == "get_all_post_comments":
+                    result = await wb_client.get_all_post_comments(**method_params)
+                elif params.method == "get_user_info":
+                    result = await wb_client.get_user_info(**method_params)
+                elif params.method == "get_all_user_posts":
+                    result = await wb_client.get_all_user_posts(**method_params)
+                elif params.method == "get_hot_posts":
+                    result = await wb_client.get_hot_posts()
+                elif params.method == "get_trending_posts":
+                    result = await wb_client.get_trending_posts()
+                else:
+                    return ActionResult(error=f"Unknown method: {params.method}")
+                
+                # Save result to file
+                timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+                filename = f"weibo_{params.method}_{timestamp}.json"
+                filepath = file_system.get_dir() / "data" / filename
+                filepath.parent.mkdir(exist_ok=True)
+                
+                with open(filepath, "w", encoding="utf-8") as f:
+                    json.dump(result, f, ensure_ascii=False, indent=2)
+                # Format result as markdown
+                if isinstance(result, list):
+                    display_count = min(5, len(result))
+                    md_content = f"## Weibo {params.method.replace('_', ' ').title()}\n\n"
+                    md_content += f"Showing {display_count} of {len(result)} results:\n\n"
+                    for i, item in enumerate(result[:display_count]):
+                        md_content += f"### Result {i+1}\n"
+                        for key, value in item.items():
+                            if not value:
+                                continue
+                            if isinstance(value, str) and len(value) > 200:
+                                md_content += f"- **{key}**: {value[:200]}...\n"
+                            else:
+                                md_content += f"- **{key}**: {value}\n"
+                        md_content += "\n"
+                else:
+                    md_content = f"## Weibo {params.method.replace('_', ' ').title()}\n\n"
+                    for key, value in result.items():
+                        if isinstance(value, str) and len(value) > 200:
+                            md_content += f"- **{key}**: {value[:200]}...\n"
+                        else:
+                            md_content += f"- **{key}**: {value}\n"
+                    md_content += "\n"
+                
+                # Add file path to markdown
+                relative_path = str(filepath.relative_to(file_system.get_dir()))
+                md_content += f"\n> 📁 Full data saved to: [{filename}]({relative_path})\n"
+                md_content += f"> 💡 Click the link above to view all results.\n"
+                
+                logger.info(f'🐦 Weibo data retrieved with method: {params.method}')
+                
+                # Close client
+                await wb_client.close()
+                
+                return ActionResult(
+                    extracted_content=md_content
+                )
+                
+            except Exception as e:
+                import traceback
+                traceback.print_exc()
+                error_msg = f'❌ Failed to retrieve Weibo data: {str(e)}. \nMost likely you are not login, please go to: [Weibo login page](https://passport.weibo.com/sso/signin?entry=miniblog&source=miniblog) and login.'
+                logger.error(error_msg)
+                return ActionResult(error=error_msg, extracted_content=error_msg)
+
+
+        @self.registry.action(
+            'Skill: Douyin API - Access Douyin platform data including search, video details, comments, user profiles, and videos. Methods: search_content_by_keyword, fetch_video_details, fetch_all_video_comments, fetch_user_info, fetch_all_user_videos.',
+            param_model=SkillDouyinAction,
+        )
+        async def skill_douyin(
+                params: SkillDouyinAction,
+                browser_manager: BrowserManager,
+                file_system: CustomFileSystem
+        ):
+            """
+            Skill: Douyin API integration
+            
+            Available methods:
+            - search_content_by_keyword: Search content by keyword with filtering options
+            - fetch_video_details: Get detailed information about specific video
+            - fetch_all_video_comments: Get all comments for specific video
+            - fetch_user_info: Get user profile information
+            - fetch_all_user_videos: Get all videos by a user
+            """
+            try:
+                from vibe_surf.tools.website_api.douyin.client import DouyinApiClient
+                
+                # Initialize client
+                dy_client = DouyinApiClient(browser_session=browser_manager.main_browser_session)
+                await dy_client.setup()
+                
+                # Parse params JSON string
+                import json
+                from json_repair import repair_json
+                try:
+                    method_params = json.loads(params.params)
+                except json.JSONDecodeError:
+                    method_params = json.loads(repair_json(params.params))
+                
+                # Execute the requested method
+                result = None
+                if params.method == "search_content_by_keyword":
+                    result = await dy_client.search_content_by_keyword(**method_params)
+                elif params.method == "fetch_video_details":
+                    result = await dy_client.fetch_video_details(**method_params)
+                elif params.method == "fetch_all_video_comments":
+                    result = await dy_client.fetch_all_video_comments(**method_params)
+                elif params.method == "fetch_user_info":
+                    result = await dy_client.fetch_user_info(**method_params)
+                elif params.method == "fetch_all_user_videos":
+                    result = await dy_client.fetch_all_user_videos(**method_params)
+                else:
+                    return ActionResult(error=f"Unknown method: {params.method}")
+                
+                # Save result to file
+                timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+                filename = f"douyin_{params.method}_{timestamp}.json"
+                filepath = file_system.get_dir() / "data" / filename
+                filepath.parent.mkdir(exist_ok=True)
+                
+                with open(filepath, "w", encoding="utf-8") as f:
+                    json.dump(result, f, ensure_ascii=False, indent=2)
+                
+                # Format result as markdown
+                if isinstance(result, list):
+                    display_count = min(5, len(result))
+                    md_content = f"## Douyin {params.method.replace('_', ' ').title()}\n\n"
+                    md_content += f"Showing {display_count} of {len(result)} results:\n\n"
+                    for i, item in enumerate(result[:display_count]):
+                        md_content += f"### Result {i+1}\n"
+                        for key, value in item.items():
+                            if not value:
+                                continue
+                            if isinstance(value, str) and len(value) > 200:
+                                md_content += f"- **{key}**: {value[:200]}...\n"
+                            else:
+                                md_content += f"- **{key}**: {value}\n"
+                        md_content += "\n"
+                else:
+                    md_content = f"## Douyin {params.method.replace('_', ' ').title()}\n\n"
+                    for key, value in result.items():
+                        if isinstance(value, str) and len(value) > 200:
+                            md_content += f"- **{key}**: {value[:200]}...\n"
+                        else:
+                            md_content += f"- **{key}**: {value}\n"
+                    md_content += "\n"
+                
+                # Add file path to markdown
+                relative_path = str(filepath.relative_to(file_system.get_dir()))
+                md_content += f"\n> 📁 Full data saved to: [{filename}]({relative_path})\n"
+                md_content += f"> 💡 Click the link above to view all results.\n"
+                
+                logger.info(f'🎵 Douyin data retrieved with method: {params.method}')
+                
+                # Close client
+                await dy_client.close()
+                
+                return ActionResult(
+                    extracted_content=md_content
+                )
+                
+            except Exception as e:
+                error_msg = f'❌ Failed to retrieve Douyin data: {str(e)}'
+                logger.error(error_msg)
+                return ActionResult(error=error_msg, extracted_content=error_msg)
+
+
+        @self.registry.action(
+            'Skill: YouTube API - Access YouTube platform data including search, video details, comments, channel info, and trending videos. Methods: search_videos, get_video_details, get_video_comments, get_channel_info, get_channel_videos, get_trending_videos.',
+            param_model=SkillYoutubeAction,
+        )
+        async def skill_youtube(
+                params: SkillYoutubeAction,
+                browser_manager: BrowserManager,
+                file_system: CustomFileSystem
+        ):
+            """
+            Skill: YouTube API integration
+            
+            Available methods:
+            - search_videos: Search videos by keyword
+            - get_video_details: Get detailed information about specific video
+            - get_video_comments: Get comments for specific video
+            - get_channel_info: Get channel information
+            - get_channel_videos: Get videos from specific channel
+            - get_trending_videos: Get trending videos
+            """
+            try:
+                from vibe_surf.tools.website_api.youtube.client import YouTubeApiClient
+                
+                # Initialize client
+                yt_client = YouTubeApiClient(browser_session=browser_manager.main_browser_session)
+                await yt_client.setup()
+                
+                # Parse params JSON string
+                import json
+                from json_repair import repair_json
+                try:
+                    method_params = json.loads(params.params)
+                except json.JSONDecodeError:
+                    method_params = json.loads(repair_json(params.params))
+                
+                # Execute the requested method
+                result = None
+                if params.method == "search_videos":
+                    result = await yt_client.search_videos(**method_params)
+                elif params.method == "get_video_details":
+                    result = await yt_client.get_video_details(**method_params)
+                elif params.method == "get_video_comments":
+                    result = await yt_client.get_video_comments(**method_params)
+                elif params.method == "get_channel_info":
+                    result = await yt_client.get_channel_info(**method_params)
+                elif params.method == "get_channel_videos":
+                    result = await yt_client.get_channel_videos(**method_params)
+                elif params.method == "get_trending_videos":
+                    result = await yt_client.get_trending_videos()
+                else:
+                    return ActionResult(error=f"Unknown method: {params.method}")
+                
+                # Save result to file
+                timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+                filename = f"youtube_{params.method}_{timestamp}.json"
+                filepath = file_system.get_dir() / "data" / filename
+                filepath.parent.mkdir(exist_ok=True)
+                
+                with open(filepath, "w", encoding="utf-8") as f:
+                    json.dump(result, f, ensure_ascii=False, indent=2)
+                
+                # Format result as markdown
+                if isinstance(result, list):
+                    display_count = min(5, len(result))
+                    md_content = f"## YouTube {params.method.replace('_', ' ').title()}\n\n"
+                    md_content += f"Showing {display_count} of {len(result)} results:\n\n"
+                    for i, item in enumerate(result[:display_count]):
+                        md_content += f"### Result {i+1}\n"
+                        for key, value in item.items():
+                            if not value:
+                                continue
+                            if isinstance(value, str) and len(value) > 200:
+                                md_content += f"- **{key}**: {value[:200]}...\n"
+                            else:
+                                md_content += f"- **{key}**: {value}\n"
+                        md_content += "\n"
+                else:
+                    md_content = f"## YouTube {params.method.replace('_', ' ').title()}\n\n"
+                    for key, value in result.items():
+                        if isinstance(value, str) and len(value) > 200:
+                            md_content += f"- **{key}**: {value[:200]}...\n"
+                        else:
+                            md_content += f"- **{key}**: {value}\n"
+                    md_content += "\n"
+                
+                # Add file path to markdown
+                relative_path = str(filepath.relative_to(file_system.get_dir()))
+                md_content += f"\n> 📁 Full data saved to: [{filename}]({relative_path})\n"
+                md_content += f"> 💡 Click the link above to view all results.\n"
+                
+                logger.info(f'🎬 YouTube data retrieved with method: {params.method}')
+                
+                # Close client
+                await yt_client.close()
+                
+                return ActionResult(
+                    extracted_content=md_content
+                )
+                
+            except Exception as e:
+                error_msg = f'❌ Failed to retrieve YouTube data: {str(e)}'
+                logger.error(error_msg)
+                return ActionResult(error=error_msg, extracted_content=error_msg)
 
 
     async def _extract_google_results_rule_based(self, browser_session):
@@ -1075,7 +1517,7 @@ Please generate alternative JavaScript code that avoids this system error:"""
             results = await self._extract_google_results_rule_based(browser_session)
             if results and len(results) > 0:
                 # Rule-based extraction succeeded
-                logger.info(f"Rule-based extraction found {len(results)} results for query: {query}")
+                logger.debug(f"Rule-based extraction found {len(results)} results for query: {query}")
                 return results[:search_ret_len]  # Return top 6 results
             
             # Fallback to LLM extraction if rule-based fails

vibe_surf/tools/views.py

@@ -211,3 +211,78 @@ class SkillFinanceAction(BaseModel):
         ge=1,
         le=20,
     )
+
+
+class DownloadMediaAction(BaseModel):
+    """Parameters for downloading media from URL"""
+    url: str = Field(
+        description='URL of the media to download',
+    )
+    filename: str | None = Field(
+        default=None,
+        description='Optional custom filename. If not provided, will auto-detect from URL or Content-Disposition header',
+    )
+ 
+
+class SkillXhsAction(BaseModel):
+    """Parameters for skill_xhs action - Xiaohongshu API skill"""
+    method: str = Field(
+        description='''Xiaohongshu API method name. Available methods:
+        - search_content_by_keyword: Search content by keyword, params required: {"keyword": "search keyword", "page": 1, "page_size": 20}
+        - fetch_content_details: Get content details, params required: {"content_id": "content ID", "xsec_token": "security token"}
+        - fetch_all_content_comments: Get all comments for content, params required: {"content_id": "content ID", "xsec_token": "security token", "max_comments": 100}
+        - get_user_profile: Get user profile, params required: {"user_id": "user ID"}
+        - fetch_all_user_content: Get all content by user, params required: {"user_id": "user ID", "max_content": 100}
+        - get_home_recommendations: Get home page recommendations, params: {}'''
+    )
+    params: str = Field(
+        description='JSON string of method parameters, provide corresponding parameters according to the method parameter. Example: {"keyword": "food"}'
+    )
+
+
+class SkillWeiboAction(BaseModel):
+    """Parameters for skill_weibo action - Weibo API skill"""
+    method: str = Field(
+        description='''Weibo API method name. Available methods:
+        - search_posts_by_keyword: Search posts by keyword, params required: {"keyword": "search keyword", "page": 1}
+        - get_post_detail: Get post details, params required: {"mid": "post ID"}
+        - get_all_post_comments: Get all comments for post, params required: {"mid": "post ID", "max_comments": 100}
+        - get_user_info: Get user information, params required: {"user_id": "user ID"}
+        - get_all_user_posts: Get all posts by user, params required: {"user_id": "user ID", "max_posts": 100}
+        - get_hot_posts: Get hot posts(推荐榜）, params: {}
+        - get_trending_posts: Get trending posts(热搜榜）, params: {}'''
+    )
+    params: str = Field(
+        description='JSON string of method parameters, provide corresponding parameters according to the method parameter. Example: {"keyword": "AI trending"}'
+    )
+
+
+class SkillDouyinAction(BaseModel):
+    """Parameters for skill_douyin action - Douyin API skill"""
+    method: str = Field(
+        description='''Douyin API method name. Available methods:
+        - search_content_by_keyword: Search videos by keyword, params required: {"keyword": "search keyword", "offset": 0}
+        - fetch_video_details: Get video details, params required: {"aweme_id": "video ID"}
+        - fetch_all_video_comments: Get all comments for video, params required: {"aweme_id": "video ID", "max_comments": 100}
+        - fetch_user_info: Get user information, params required: {"sec_user_id": "user security ID"}
+        - fetch_all_user_videos: Get all videos by user, params required: {"sec_user_id": "user security ID", "max_videos": 100}'''
+    )
+    params: str = Field(
+        description='JSON string of method parameters, provide corresponding parameters according to the method parameter. Example: {"keyword": "music"}'
+    )
+
+
+class SkillYoutubeAction(BaseModel):
+    """Parameters for skill_youtube action - YouTube API skill"""
+    method: str = Field(
+        description='''YouTube API method name. Available methods:
+        - search_videos: Search videos, params required: {"query": "search keyword", "max_results": 20}
+        - get_video_details: Get video details, params required: {"video_id": "video ID"}
+        - get_video_comments: Get video comments, params required: {"video_id": "video ID", "max_comments": 200}
+        - get_channel_info: Get channel information, params required: {"channel_id": "channel ID"}
+        - get_channel_videos: Get channel videos, params required: {"channel_id": "channel ID", "max_videos": 20}
+        - get_trending_videos: Get trending videos, params: {}'''
+    )
+    params: str = Field(
+        description='JSON string of method parameters, provide corresponding parameters according to the method parameter. Example: {"query": "tech tutorial", "max_results": 30}'
+    )