vibesurf 0.1.0__py3-none-any.whl

vibe_surf/agents/prompts/__init__.py

@@ -0,0 +1 @@
+# Prompts module for VibeSurf agents

vibe_surf/agents/prompts/vibe_surf_prompt.py

@@ -0,0 +1,176 @@
+# Supervisor Agent System Prompt - Core controller role definition
+SUPERVISOR_AGENT_SYSTEM_PROMPT = """
+You are the VibeSurf Agent developed by [WarmShao](https://github.com/warmshao), you are a helpful browser assistant, the core controller of the browser automating. You manage todo lists, assign tasks, and coordinate the entire execution process.
+Your mission is to do your best to help users vibe surfing the internet, the world and the future.
+
+You may receive context in the user message with these keys(subset):
+- User's New Request: The user's initial request with Upload Files(Optional, used for completed task or request). Always prioritize and execute the user's latest extracted request unless it's a supplement or continuation of previous tasks, in which case combine previous requests and results for informed decision-making.
+- Current Todos: List of pending todo items that need completion in previous stage
+- Completed Todos: List of already finished todo items with their results
+- Previous Browser Execution Results: Results from previous executed browser automation tasks
+- Generated Report Path: Generated report path from report writer agent
+- Available Browser Tabs: Current available browser tabs(pages), format as [page_index] Page Title, Page Url and Page ID
+
+Your responsibilities:
+1. TODO Management: Generate initial todos if none exist, or update todos based on task results
+2. Task Assignment: Decide whether to assign browser tasks (parallel/single) or report tasks(if user specified)
+3. Progress Tracking: Determine if tasks are complete and ready for summary
+
+Todo Item Creation and Update Guidelines:
+- Keep todo items simple and goal-oriented (especially for browser agents)
+- Focus on WHAT you want to achieve and WHAT results you expect
+- DO NOT include detailed step-by-step instructions or implementation details
+- DO NOT over-split tasks into too many granular items - keep logical groupings together
+- Browser agents have strong planning and execution capabilities - they only need task descriptions and desired outcomes
+- If this task requires some contextual information from previous result, please also describe it in the task, such as which file paths need to be read from and etc.
+- Example: "Search for latest iPhone 15 prices and return comparison data" (NOT "Go to Apple website, navigate to iPhone section, find iPhone 15, check prices...")
+
+Available Actions:
+- "simple_response": Directly return response content or answer if you think this is a simple task, such as Basic calculations or conversions or General advice or recommendations based on common knowledge and etc.
+- "generate_todos": Create initial todo list (only if no todos exist)
+- "update_todos": Update or Replace all remaining todos based on results and progress
+- "assign_browser_task": Assign browser automation tasks
+- "assign_report_task": Assign HTML report generation task
+- "summary_generation": Generate final markdown summary and complete the workflow when all requirements have been met
+
+Task Assignment Guidelines:
+- Browser tasks: Use when web research, data extraction, or automation is needed
+- Report tasks: Use when user explicitly requests reports or when complex data needs structured presentation. 
+
+File Processing Capabilities:
+- Browser agent can read and process various file types (text, documents, images, etc.)
+- Browser agent can extract information from files and perform file analysis
+- When users upload files for processing, summarization, or analysis tasks, these can be assigned to browser agent
+- When creating file-related tasks, always include the specific absolute file paths in the task description. The path format provided by the user is generally like this: file:///{absolute file path}, Please only use the absolute file path.
+- Examples: "Read and summarize the content from file path: path/to/document.pdf", "Analyze data from uploaded file: path/to/data.csv and generate insights"
+
+Browser Task Execution Mode Rules:
+- "single": Use for tasks on user-opened pages (form filling, automation on existing pages, dependent sequential tasks). ONLY supports 1 task.
+- "parallel": Use for independent research tasks (web searching, deep research, data extraction from multiple sources) that can run concurrently for efficiency.
+
+Browser Tab Management Guidelines:
+
+**Single Mode:**
+- No need to specify page_index - automatically uses the current active page
+- Browser use agent can see all available tabs for context
+- Default behavior works on the currently active tab
+
+**Parallel Mode:**
+- When generating tasks_to_execute, you can optionally specify page index using format: [[page_index, todo_index], [page_index, todo_index], todo_index]
+- Examples: [[1, 0], [0, 1], 2] (execute todo_item[0] on page 1, todo_item[1] on page 0, todo_item[2] on new page)
+- If page_index is specified: Agent will work on that specific page (may affect user's opened web pages)
+- If page_index is NOT specified: Agent will open a new blank page to work on
+- IMPORTANT: Only specify page_index when:
+  - User explicitly requests work on already opened pages, OR
+  - The target page is a blank page, OR  
+  - Task only involves simple information gathering from open pages (no automation that changes page state)
+- Parallel mode agents only see their specified page or newly opened page (isolation implemented)
+- Avoid specifying page_index for tasks that involve automation unless explicitly requested by user
+
+
+Browser Task Execution Requirements:
+- For "assign_browser_task" action, use todo item indices in "tasks_to_execute" to reference items from "todo_items"
+- Format: use integer indices (0-based) to reference todo_items, or [page_index, todo_index] for specific page assignment
+- This ensures efficient referencing and proper tracking of todo items without duplication
+
+Decision Rules:
+- If no todos exist: generate_todos
+- If browser tasks are pending: assign_browser_task
+- If all browser tasks complete and user wants report: assign_report_task
+- If all tasks complete: summary_generation
+
+IMPORTANT: For "update_todos" action, always provide the complete list of remaining todo items to replace the current todo list. This ensures proper modification and cleanup of completed or unnecessary todos.
+
+Respond with JSON in this exact format:
+{{
+    "reasoning": "explanation of current situation and decision",
+    "action": "simple_response|generate_todos|update_todos|assign_browser_task|assign_report_task|summary_generation",
+    "simple_response_content": "the actual response content if this is a simple response task. Just directly write the answer, no more extra content.",
+    "summary_content": "the comprehensive markdown summary content when action is summary_generation. Include key findings, results, and links to generated files. For local file links, use the file:// protocol format: [Report Name](file:///absolute/path/to/file.html) to ensure proper file access in browser extensions.",
+    "todo_items": ["complete list of remaining todos - ALWAYS include for generate_todos and update_todos actions"],
+    "task_type": "parallel|single (for browser tasks)",
+    "tasks_to_execute": ["todo indices to execute now - use 0-based indices referencing todo_items, ONLY 1 index for single mode. For parallel mode, optionally use [[page_index, todo_index], todo_index] format to specify page"]
+}}
+
+The language of your output should remain the same as the user's request, including the content of the reasoning, response, todo list, browser task and etc. in values of JSON, but the names of the keys in the JSON should remain in English.
+"""
+
+REPORT_CONTENT_PROMPT = """
+You are a professional report writer tasked with creating content that directly fulfills the user's request.
+
+**User's Original Request:** {original_task}
+**Report Type:** {report_type}
+**Available Data:** {execution_results}
+
+**Instructions:**
+1. Focus ONLY on what the user specifically requested - ignore technical execution details
+2. Create content that directly addresses the user's needs (comparison, analysis, research findings, etc.)
+3. DO NOT include methodology, task overview, or technical process information
+4. DO NOT mention agents, browser automation, or technical execution methods
+5. Write as if you're delivering exactly what the user asked for
+6. Use a professional, clear, and engaging style
+7. Structure content with clear sections relevant to the user's request
+8. If images or screenshots are available and would enhance the report presentation, include them in appropriate locations with proper context and descriptions
+
+**Content Structure (adapt based on user's request):**
+- Executive Summary (key findings relevant to user's request)
+- Main Content (comparison, analysis, research findings - whatever user requested)
+- Key Insights & Findings (specific to user's topic of interest)
+- Conclusions & Recommendations (actionable insights for user's domain)
+
+**Writing Style:**
+- Professional and authoritative
+- Data-driven with specific examples from the research
+- Clear and concise
+- Focus on subject matter insights, not process
+- NO technical jargon about execution methods
+
+Generate content that directly fulfills the user's request. Pretend you're a domain expert delivering exactly what they asked for.
+"""
+
+REPORT_FORMAT_PROMPT = """
+Create a beautiful, professional HTML report. Output ONLY the HTML code with no explanation or additional text.
+
+**Content to Format:**
+{report_content}
+
+**CRITICAL: Output Rules**
+- Output ONLY HTML code starting with <!DOCTYPE html>
+- NO introductory text, explanations, or comments before the HTML
+- NO text after the HTML code
+- NO markdown code blocks or formatting
+- JUST the raw HTML document
+
+**Design Requirements:**
+1. Modern, professional HTML document with embedded CSS
+2. Clean, readable design with proper typography
+3. Responsive design principles
+4. Professional color scheme (blues, grays, whites)
+5. Proper spacing, margins, and visual hierarchy
+6. Print-friendly design
+7. Modern CSS features (flexbox, grid where appropriate)
+
+**Structure Requirements:**
+- Header with appropriate title (derived from content, NOT "Task Execution Report")
+- Clearly defined sections with proper headings
+- Data tables with professional styling
+- Visual elements where appropriate
+- Images and screenshots with proper styling, captions, and responsive design
+- Clean footer
+
+**Technical Requirements:**
+- Complete HTML5 document with proper DOCTYPE
+- Embedded CSS (no external dependencies)
+- Responsive meta tags
+- Semantic HTML elements
+- Cross-browser compatibility
+- Proper image handling with responsive design, appropriate sizing, and elegant layout
+- Image captions and alt text for accessibility
+
+**Title Guidelines:**
+- Create title based on the actual content/comparison topic
+- NOT "Task Execution Report" or similar generic titles
+- Make it specific to what was researched/compared
+
+IMPORTANT: Start your response immediately with <!DOCTYPE html> and output ONLY the HTML document.
+"""

vibe_surf/agents/report_writer_agent.py

@@ -0,0 +1,360 @@
+import logging
+import os
+import time
+from typing import Any, Dict, List
+
+from browser_use.llm.base import BaseChatModel
+from browser_use.llm.messages import UserMessage
+
+from vibe_surf.agents.prompts.vibe_surf_prompt import (
+    REPORT_CONTENT_PROMPT,
+    REPORT_FORMAT_PROMPT
+)
+
+logger = logging.getLogger(__name__)
+
+
+class ReportWriterAgent:
+    """Agent responsible for generating HTML reports using two-phase LLM generation"""
+    
+    def __init__(self, llm: BaseChatModel, workspace_dir: str):
+        """
+        Initialize ReportWriterAgent
+        
+        Args:
+            llm: Language model for generating report content
+            workspace_dir: Directory to save reports
+        """
+        self.llm = llm
+        self.workspace_dir = workspace_dir
+        
+        logger.info("📄 ReportWriterAgent initialized")
+    
+    async def generate_report(self, report_data: Dict[str, Any]) -> str:
+        """
+        Generate HTML report using two-phase approach: content generation then formatting
+        
+        Args:
+            report_data: Dictionary containing:
+                - original_task: The original user task
+                - execution_results: List of BrowserTaskResult objects
+                - report_type: Type of report ("summary", "detailed", "none")
+                - upload_files: Optional list of uploaded files
+        
+        Returns:
+            str: Path to the generated report file
+        """
+        logger.info(f"📝 Generating {report_data.get('report_type', 'summary')} report...")
+        
+        try:
+            # Phase 1: Generate report content
+            logger.info("📖 Phase 1: Generating report content...")
+            report_content = await self._generate_content(report_data)
+            
+            # Phase 2: Format content as HTML
+            logger.info("🎨 Phase 2: Formatting as HTML...")
+            html_content = await self._format_as_html(report_content)
+            
+            # Save report to file
+            report_filename = f"report_{int(time.time())}.html"
+            reports_dir = os.path.join(self.workspace_dir, "reports")
+            os.makedirs(reports_dir, exist_ok=True)
+            report_path = os.path.join(reports_dir, report_filename)
+            
+            with open(report_path, 'w', encoding='utf-8') as f:
+                f.write(html_content)
+            
+            logger.info(f"✅ Report generated successfully: {report_path}")
+            return report_path
+            
+        except Exception as e:
+            logger.error(f"❌ Failed to generate report: {e}")
+            # Generate a simple fallback report
+            fallback_path = await self._generate_fallback_report(report_data)
+            return fallback_path
+    
+    async def _generate_content(self, report_data: Dict[str, Any]) -> str:
+        """Generate the textual content for the report"""
+        # Format execution results for the prompt
+        results_text = self._format_execution_results(report_data.get('execution_results', []))
+        
+        # Format upload files
+        upload_files = report_data.get('upload_files', [])
+        upload_files_text = "None" if not upload_files else ", ".join(upload_files)
+        
+        # Generate content using the content prompt
+        content_prompt = REPORT_CONTENT_PROMPT.format(
+            original_task=report_data.get('original_task', 'No task specified'),
+            report_type=report_data.get('report_type', 'summary'),
+            upload_files=upload_files_text,
+            execution_results=results_text
+        )
+        
+        response = await self.llm.ainvoke([UserMessage(content=content_prompt)])
+        return response.completion
+    
+    async def _format_as_html(self, content: str) -> str:
+        """Format the content as a professional HTML document"""
+        format_prompt = REPORT_FORMAT_PROMPT.format(report_content=content)
+        
+        response = await self.llm.ainvoke([UserMessage(content=format_prompt)])
+        html_content = response.completion
+        
+        # Clean up the HTML content if needed
+        html_content = self._clean_html_content(html_content)
+        
+        return html_content
+    
+    def _format_execution_results(self, execution_results) -> str:
+        """Format execution results for the LLM prompt"""
+        if not execution_results:
+            return "No execution results available."
+        
+        formatted_results = []
+        for i, result in enumerate(execution_results, 1):
+            status = "✅ Success" if result.success else "❌ Failed"
+            
+            # Extract meaningful result content
+            result_content = "No result available"
+            if result.result:
+                # Truncate very long results but keep meaningful content
+                if len(result.result) > 500:
+                    result_content = result.result[:497] + "..."
+                else:
+                    result_content = result.result
+            elif result.error:
+                result_content = f"Error: {result.error}"
+            
+            formatted_results.append(f"""
+**Task {i}:** {result.task}
+**Status:** {status}
+**Agent:** {result.agent_id}
+**Result:** {result_content}
+**Success:** {'Yes' if result.success else 'No'}
+            """)
+        
+        return "\n".join(formatted_results)
+    
+    def _clean_html_content(self, html_content: str) -> str:
+        """Clean and validate HTML content"""
+        # Remove markdown code block markers if present
+        html_content = html_content.strip()
+        if html_content.startswith("```html"):
+            html_content = html_content[7:].strip()
+        if html_content.startswith("```"):
+            html_content = html_content[3:].strip()
+        if html_content.endswith("```"):
+            html_content = html_content[:-3].strip()
+        
+        # Ensure it starts with <!DOCTYPE html> or <html>
+        if not html_content.lower().startswith(('<!doctype', '<html')):
+            html_content = f"""<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>VibeSurf Task Report</title>
+    <style>
+        body {{ font-family: Arial, sans-serif; margin: 20px; line-height: 1.6; }}
+        .container {{ max-width: 800px; margin: 0 auto; }}
+        h1 {{ color: #2c3e50; border-bottom: 2px solid #3498db; padding-bottom: 10px; }}
+        h2 {{ color: #34495e; margin-top: 30px; }}
+        .section {{ margin: 20px 0; padding: 15px; background: #f8f9fa; border-left: 4px solid #007bff; }}
+    </style>
+</head>
+<body>
+    <div class="container">
+        {html_content}
+    </div>
+</body>
+</html>"""
+        
+        return html_content
+    
+    async def _generate_fallback_report(self, report_data: Dict[str, Any]) -> str:
+        """Generate a simple fallback report when LLM generation fails"""
+        logger.info("📝 Generating fallback report...")
+        
+        upload_files = report_data.get('upload_files', [])
+        upload_files_section = ""
+        if upload_files:
+            upload_files_section = f"""
+    <div class="section">
+        <h2>Upload Files</h2>
+        <ul>
+            {"".join([f"<li>{file}</li>" for file in upload_files])}
+        </ul>
+    </div>"""
+        
+        # Create a simple HTML report
+        html_content = f"""<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>VibeSurf Task Report</title>
+    <style>
+        body {{
+            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+            max-width: 1000px;
+            margin: 0 auto;
+            padding: 20px;
+            line-height: 1.6;
+            color: #333;
+            background-color: #f8f9fa;
+        }}
+        .container {{
+            background: white;
+            border-radius: 8px;
+            box-shadow: 0 2px 10px rgba(0,0,0,0.1);
+            overflow: hidden;
+        }}
+        .header {{
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            color: white;
+            padding: 30px;
+            text-align: center;
+        }}
+        .header h1 {{
+            margin: 0;
+            font-size: 2.2em;
+            font-weight: 300;
+        }}
+        .section {{
+            margin: 0;
+            padding: 25px;
+            border-bottom: 1px solid #eee;
+        }}
+        .section:last-child {{
+            border-bottom: none;
+        }}
+        .section h2 {{
+            color: #2c3e50;
+            margin-top: 0;
+            margin-bottom: 15px;
+            font-size: 1.4em;
+            border-left: 4px solid #3498db;
+            padding-left: 15px;
+        }}
+        .success {{
+            color: #27ae60;
+            font-weight: 600;
+        }}
+        .error {{
+            color: #e74c3c;
+            font-weight: 600;
+        }}
+        table {{
+            width: 100%;
+            border-collapse: collapse;
+            margin-top: 15px;
+            background: white;
+            border-radius: 6px;
+            overflow: hidden;
+            box-shadow: 0 1px 3px rgba(0,0,0,0.1);
+        }}
+        th, td {{
+            padding: 15px;
+            text-align: left;
+            border-bottom: 1px solid #eee;
+        }}
+        th {{
+            background: #34495e;
+            color: white;
+            font-weight: 600;
+        }}
+        tr:hover {{
+            background-color: #f8f9fa;
+        }}
+        .meta {{
+            background: #ecf0f1;
+            color: #7f8c8d;
+            text-align: center;
+            padding: 15px;
+            font-size: 0.9em;
+        }}
+    </style>
+</head>
+<body>
+    <div class="container">
+        <div class="header">
+            <h1>VibeSurf Task Report</h1>
+            <p>Generated on {time.strftime('%B %d, %Y at %H:%M:%S')}</p>
+        </div>
+        
+        <div class="section">
+            <h2>Task Overview</h2>
+            <p><strong>Original Task:</strong> {report_data.get('original_task', 'No task specified')}</p>
+            <p><strong>Report Type:</strong> {report_data.get('report_type', 'summary').title()}</p>
+        </div>
+        {upload_files_section}
+        
+        <div class="section">
+            <h2>Execution Results</h2>
+            <table>
+                <thead>
+                    <tr>
+                        <th>Task</th>
+                        <th>Status</th>
+                        <th>Agent</th>
+                        <th>Result</th>
+                    </tr>
+                </thead>
+                <tbody>
+"""
+        
+        # Add execution results to table
+        execution_results = report_data.get('execution_results', [])
+        if execution_results:
+            for result in execution_results:
+                status_class = "success" if result.success else "error"
+                status_text = "✅ Success" if result.success else "❌ Failed"
+                result_text = result.result or result.error or "No result"
+                # Truncate long results
+                if len(result_text) > 150:
+                    result_text = result_text[:147] + "..."
+                
+                html_content += f"""
+                    <tr>
+                        <td>{result.task}</td>
+                        <td class="{status_class}">{status_text}</td>
+                        <td>{result.agent_id}</td>
+                        <td>{result_text}</td>
+                    </tr>
+"""
+        else:
+            html_content += """
+                    <tr>
+                        <td colspan="4" style="text-align: center; color: #7f8c8d; font-style: italic;">No execution results available</td>
+                    </tr>
+"""
+        
+        html_content += """
+                </tbody>
+            </table>
+        </div>
+        
+        <div class="section">
+            <h2>Summary</h2>
+            <p>This report was automatically generated by VibeSurf as a fallback when the advanced report generation encountered an issue. The report contains basic information about the task execution and results.</p>
+            <p>For future runs, ensure that the LLM service is properly configured and accessible for enhanced report generation capabilities.</p>
+        </div>
+        
+        <div class="meta">
+            Generated by VibeSurf Agent Framework
+        </div>
+    </div>
+</body>
+</html>"""
+        
+        # Save fallback report
+        report_filename = f"fallback_report_{int(time.time())}.html"
+        reports_dir = os.path.join(self.workspace_dir, "reports")
+        os.makedirs(reports_dir, exist_ok=True)
+        report_path = os.path.join(reports_dir, report_filename)
+        
+        with open(report_path, 'w', encoding='utf-8') as f:
+            f.write(html_content)
+        
+        logger.info(f"✅ Fallback report generated: {report_path}")
+        return report_path