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

vibe_surf/tools/vibesurf_tools.py

@@ -8,6 +8,8 @@ import json
 import enum
 import base64
 import mimetypes
+import yfinance as yf
+import pprint
 from json_repair import repair_json
 from datetime import datetime
 from typing import Optional, Type, Callable, Dict, Any, Union, Awaitable, TypeVar
@@ -29,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
+    SkillSummaryAction, SkillTakeScreenshotAction, SkillDeepResearchAction, SkillCodeAction, SkillFinanceAction
+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
 from vibe_surf.browser.browser_manager import BrowserManager
@@ -193,6 +196,7 @@ class VibeSurfTools:
                     raise RuntimeError("LLM is required for skill_search")
 
                 # Step 1: Use LLM to analyze user intent and generate different search tasks
+                query_num = 6
                 from datetime import datetime
                 analysis_prompt = f"""
 Analyze the user query and generate 5 different Google search strategies to comprehensively find relevant information.
@@ -201,13 +205,13 @@ Current Time: {datetime.now().isoformat()}
 
 User Query: "{params.query}"
 
-Generate 5 different search queries that approach this topic from different angles. Each search should be:
+Generate {query_num} different search queries that approach this topic from different angles. Each search should be:
 1. Specific and concrete (good for Google search)
 2. Different from the others (different perspectives/aspects)
 3. Likely to return valuable, unique information
 
-Return your response as a JSON array of 5 search query strings.
-Example format: ["query 1", "query 2", "query 3", "query 4", "query 5"]
+Return your response as a JSON array of {query_num} search query strings.
+Example format: ["query 1", "query 2", "query 3", "query 4", "query 5", "query 6"]
 """
 
                 from browser_use.llm.messages import SystemMessage, UserMessage
@@ -222,7 +226,7 @@ Example format: ["query 1", "query 2", "query 3", "query 4", "query 5"]
                     search_queries = json.loads(response.completion.strip())
                     if not isinstance(search_queries, list):
                         raise ValueError("Invalid search queries format")
-                    search_queries = search_queries[:5]
+                    search_queries = search_queries[:query_num]
                 except (json.JSONDecodeError, ValueError):
                     # Fallback to simple queries if parsing fails
                     try:
@@ -255,7 +259,6 @@ Example format: ["query 1", "query 2", "query 3", "query 4", "query 5"]
                     search_tasks.append(self._perform_google_search(browser_session, query, llm))
 
                 search_results = await asyncio.gather(*search_tasks, return_exceptions=True)
-
                 # Step 4: Aggregate and filter results
                 all_results = []
                 for i, result in enumerate(search_results):
@@ -265,18 +268,24 @@ Example format: ["query 1", "query 2", "query 3", "query 4", "query 5"]
                     if result:
                         all_results.extend(result)
 
-                # Step 5: Use LLM to deduplicate and rank top 10 results
-                if all_results:
+                # Step 4.5: Rule-based deduplication to reduce LLM processing load
+                # if all_results:
+                #     deduplicated_results = self._rule_based_deduplication(all_results)
+                #     logger.info(f"Rule-based deduplication: {len(all_results)} -> {len(deduplicated_results)} results")
+                # else:
+                #     deduplicated_results = []
+
+                # 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
                     ranking_prompt = f"""
-Given these search results for the query "{params.query}", please:
-1. Remove duplicates (same or very similar content)
-2. Rank by relevance and value to the user
-3. Select the TOP 10 most relevant and valuable results
+Rank these search results for the query "{params.query}" by relevance and value.
+Select the TOP 10 most relevant and valuable results.
 
-Search Results:
+Search Results ({len(all_results)} total):
 {json.dumps(all_results, indent=2)}
 
-Return the top 10 results as a JSON array, with each result containing:
+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)
@@ -286,7 +295,7 @@ Format: [{{"title": "...", "url": "...", "summary": "..."}}, ...]
 
                     ranking_response = await llm.ainvoke([
                         SystemMessage(
-                            content="You are an expert at evaluating and ranking search results for relevance and value."),
+                            content="You are an expert at ranking search results for relevance and value."),
                         UserMessage(content=ranking_prompt)
                     ])
 
@@ -294,9 +303,21 @@ Format: [{{"title": "...", "url": "...", "summary": "..."}}, ...]
                         top_results = json.loads(ranking_response.completion.strip())
                         if not isinstance(top_results, list):
                             raise ValueError("Invalid ranking results format")
+                        top_results = top_results[:10]  # Ensure max 10 results
                     except (json.JSONDecodeError, ValueError):
-                        # Fallback to first 10 results if ranking fails
-                        top_results = all_results[:10]
+                        try:
+                            top_results = repair_json(ranking_response.completion.strip())
+                            if isinstance(top_results, list):
+                                top_results = top_results[:10]
+                            else:
+                                top_results = all_results[:10]
+                        except Exception:
+                            # Fallback to first 10 deduplicated results
+                            top_results = all_results[:10]
+                elif all_results:
+                    # If we have 10 or fewer results, skip LLM ranking
+                    top_results = all_results[:10]
+                    logger.info(f"Skipping LLM ranking for {len(all_results)} results (≤10)")
                 else:
                     top_results = []
 
@@ -691,7 +712,7 @@ Please fix the error and generate corrected JavaScript code:"""
                             elif isinstance(value, (dict, list)):
                                 # Complex objects - should be serialized by returnByValue
                                 try:
-                                    result_text = json.dumps(value, ensure_ascii=False)
+                                    result_text = json.dumps(value, ensure_ascii=False, indent=2)
                                 except (TypeError, ValueError):
                                     # Fallback for non-serializable objects
                                     result_text = str(value)
@@ -726,7 +747,7 @@ The result is empty or not useful. Please generate improved JavaScript code that
                                 result_text = result_text[:30000] + '\n... [Truncated after 30000 characters]'
 
                             # Success! Return the result
-                            msg = f'Requirement: {params.code_requirement}\n\nGenerated Code (Iteration {iteration}): \n```javascript\n{generated_js_code}\n```\nResult: {result_text}'
+                            msg = f'Generated Code (Iteration {iteration}): \n```javascript\n{generated_js_code}\n```\nResult:\n```json\n {result_text}\n```\n'
                             logger.info(f'✅ Skill Code succeeded on iteration {iteration}')
 
                             return ActionResult(
@@ -818,19 +839,250 @@ Please generate alternative JavaScript code that avoids this system error:"""
                 include_extracted_content_only_once=True,
             )
 
+        @self.registry.action(
+            'Skill: Get comprehensive financial data for stocks - retrieve company information, historical prices, news, earnings, dividends, analyst recommendations and other financial data using Yahoo Finance. Available methods include: get_info (company info), get_history (price history), get_news (latest news), get_dividends (dividend history), get_earnings (earnings data), get_recommendations (analyst recommendations), get_balance_sheet (balance sheet data), get_income_stmt (income statement), get_cashflow (cash flow statement), get_fast_info (quick stats), get_institutional_holders (institutional ownership), get_major_holders (major shareholders), get_sustainability (ESG data), get_upgrades_downgrades (analyst upgrades/downgrades), and more. If no methods specified, defaults to get_info.',
+            param_model=SkillFinanceAction,
+        )
+        async def skill_finance(
+                params: SkillFinanceAction,
+        ):
+            """
+            Skill: Get comprehensive financial data using Yahoo Finance
+            
+            Available methods include:
+            - get_info: Company information including sector, industry, market cap, business summary
+            - get_history: Historical stock prices and volume data over time periods
+            - get_news: Latest news articles about the company
+            - get_dividends: Historical dividend payments and yield data
+            - get_earnings: Quarterly and annual earnings data and growth trends
+            - get_recommendations: Analyst recommendations, price targets, and ratings
+            - get_balance_sheet: Company balance sheet data (assets, liabilities, equity)
+            - get_income_stmt: Income statement data (revenue, expenses, profit)
+            - get_cashflow: Cash flow statement data (operating, investing, financing)
+            - get_fast_info: Quick statistics like current price, volume, market cap
+            - get_institutional_holders: Institutional ownership and holdings data
+            - get_major_holders: Major shareholders and insider ownership percentages
+            - get_sustainability: ESG (Environmental, Social, Governance) scores and data
+            - get_upgrades_downgrades: Recent analyst upgrades and downgrades
+            - get_splits: Historical stock splits and stock split dates
+            - get_actions: Corporate actions including dividends and splits
+            - get_sec_filings: Recent SEC filings and regulatory documents
+            - get_calendar: Upcoming earnings dates and events
+            - get_mutualfund_holders: Mutual fund ownership data
+            - get_insider_purchases: Recent insider buying activity
+            - get_insider_transactions: All insider trading transactions
+            - get_shares: Outstanding shares and float data
+            """
+            try:
+                # Default to get_info if no methods specified
+                methods = params.methods if params.methods else [FinanceMethod.GET_INFO]
+                
+                # Convert string methods to FinanceMethod enum if needed
+                if methods and isinstance(methods[0], str):
+                    try:
+                        methods = [FinanceMethod(method) for method in methods]
+                    except ValueError as e:
+                        available_methods = [method.value for method in FinanceMethod]
+                        return ActionResult(
+                            error=f'Invalid method in {methods}. Available methods: {available_methods}'
+                        )
+                
+                # Create data retriever with symbol
+                retriever = FinanceDataRetriever(params.symbol)
+                
+                # Convert FinanceMethod enum values to strings for the retriever
+                method_strings = [method.value for method in methods]
+                
+                # Retrieve financial data
+                financial_data = retriever.get_finance_data(
+                    methods=method_strings,
+                    period=getattr(params, 'period', '1y'),
+                    start_date=getattr(params, 'start_date', None),
+                    end_date=getattr(params, 'end_date', None),
+                    interval=getattr(params, 'interval', '1d'),
+                    num_news=getattr(params, 'num_news', 5)
+                )
+                
+                # Format as markdown using the static method
+                markdown_content = FinanceMarkdownFormatter.format_finance_data(
+                    symbol=params.symbol,
+                    results=financial_data,
+                    methods=method_strings
+                )
+                
+                method_names = [method.value for method in methods]
+                logger.info(f'💹 Comprehensive finance data retrieved for {params.symbol} with methods: {method_names}')
+                
+                return ActionResult(
+                    extracted_content=markdown_content,
+                    include_extracted_content_only_once=True,
+                    long_term_memory=f'Retrieved comprehensive financial data for {params.symbol} using methods: {", ".join(method_names)}',
+                )
+                
+            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)
+
+
+    async def _extract_google_results_rule_based(self, browser_session):
+        """Rule-based extraction of Google search results using JavaScript"""
+        try:
+            cdp_session = await browser_session.get_or_create_cdp_session()
+            
+            # JavaScript code to extract Google search results using DOM selectors
+            js_extraction_code = """
+(function() {
+    try {
+        const results = [];
+        
+        // Multiple selector strategies for different Google layouts
+        const selectors = [
+            'div[data-sokoban-container] div[data-sokoban-feature]', // Standard results
+            'div.g:not(.g-blk)', // Classic results container
+            '.tF2Cxc', // Modern result container
+            'div[data-ved] h3', // Result titles
+        ];
+        
+        let resultElements = [];
+        
+        // Try each selector until we find results
+        for (const selector of selectors) {
+            const elements = document.querySelectorAll(selector);
+            if (elements.length > 0) {
+                resultElements = Array.from(elements).slice(0, 10); // Get up to 10 results
+                break;
+            }
+        }
+        
+        // If no results found with specific selectors, try broader search
+        if (resultElements.length === 0) {
+            // Look for any divs containing h3 elements (likely search results)
+            const h3Elements = document.querySelectorAll('h3');
+            resultElements = Array.from(h3Elements)
+                .map(h3 => h3.closest('div'))
+                .filter(div => div && div.querySelector('a[href]'))
+                .slice(0, 10);
+        }
+        
+        for (let i = 0; i < Math.min(resultElements.length, 10); i++) {
+            const element = resultElements[i];
+            
+            // Extract title
+            let title = '';
+            const titleSelectors = ['h3', '[role="heading"]', 'a > span', '.LC20lb'];
+            for (const sel of titleSelectors) {
+                const titleEl = element.querySelector(sel);
+                if (titleEl && titleEl.textContent.trim()) {
+                    title = titleEl.textContent.trim();
+                    break;
+                }
+            }
+            
+            // Extract URL
+            let url = '';
+            const linkSelectors = ['a[href^="http"]', 'a[href^="/url?q="]', 'a[href]'];
+            for (const sel of linkSelectors) {
+                const linkEl = element.querySelector(sel);
+                if (linkEl && linkEl.href) {
+                    url = linkEl.href;
+                    // Clean Google redirect URLs
+                    if (url.includes('/url?q=')) {
+                        const urlMatch = url.match(/[?&]q=([^&]*)/);
+                        if (urlMatch) {
+                            url = decodeURIComponent(urlMatch[1]);
+                        }
+                    }
+                    break;
+                }
+            }
+            
+            // Extract summary/description
+            let summary = '';
+            const summarySelectors = [
+                '.VwiC3b', // Description text
+                '.yXK7lf', // Snippet text
+                '[data-content-feature="1"] span',
+                '.s', // Classic description
+                'span:not(:has(a))'
+            ];
+            for (const sel of summarySelectors) {
+                const summaryEl = element.querySelector(sel);
+                if (summaryEl && summaryEl.textContent.trim() && summaryEl.textContent.length > 10) {
+                    summary = summaryEl.textContent.trim();
+                    break;
+                }
+            }
+            
+            // Only add if we have at least title or URL
+            if (title || url) {
+                results.push({
+                    title: title || 'No title',
+                    url: url || 'No URL',
+                    summary: summary || 'No description available'
+                });
+            }
+        }
+        
+        return JSON.stringify(results);
+        
+    } catch (e) {
+        return JSON.stringify([{
+            title: 'Error extracting results',
+            url: window.location.href,
+            summary: 'JavaScript extraction failed: ' + e.message
+        }]);
+    }
+})()
+"""
+            
+            # Execute JavaScript to extract results
+            result = await cdp_session.cdp_client.send.Runtime.evaluate(
+                params={'expression': js_extraction_code, 'returnByValue': True, 'awaitPromise': True},
+                session_id=cdp_session.session_id,
+            )
+            
+            if result.get('exceptionDetails'):
+                logger.warning(f"JavaScript extraction failed: {result['exceptionDetails']}")
+                return []
+            
+            result_data = result.get('result', {})
+            value = result_data.get('value', '[]')
+            
+            try:
+                extracted_results = json.loads(value)
+                return extracted_results if isinstance(extracted_results, list) else []
+            except (json.JSONDecodeError, ValueError):
+                logger.warning(f"Failed to parse extraction results: {value}")
+                return []
+                
+        except Exception as e:
+            logger.error(f"Rule-based extraction failed: {e}")
+            return []
+
     async def _perform_google_search(self, browser_session, query: str, llm: BaseChatModel):
-        """Helper method to perform Google search and extract top 5 results"""
+        """Helper method to perform Google search and extract top 5 results using rule-based extraction"""
         try:
             # Navigate to Google search
             search_url = f'https://www.google.com/search?q={query}&udm=14'
             await browser_session.navigate_to_url(search_url, new_tab=False)
 
             # Wait a moment for page to load
-            await asyncio.sleep(1)
-
-            # Extract structured content
+            await asyncio.sleep(2)
+
+            # Use rule-based extraction first (much faster than LLM)
+            search_ret_len = 10
+            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}")
+                return results[:search_ret_len]  # Return top 6 results
+            
+            # Fallback to LLM extraction if rule-based fails
+            logger.warning(f"Rule-based extraction failed for query '{query}', falling back to LLM")
+            
             extraction_query = f"""
-Extract the top 5 search results from this Google search page. For each result, provide:
+Extract the top {search_ret_len} search results from this Google search page. For each result, provide:
 - title: The clickable title/headline
 - url: The website URL
 - summary: A brief description of what this result contains
@@ -841,18 +1093,17 @@ Return results as a JSON array: [{{"title": "...", "url": "...", "summary": "...
             results_text = await self._extract_structured_content(browser_session, extraction_query, llm)
 
             # Try to parse JSON results
-            import json
             try:
                 results = json.loads(results_text.strip())
                 if isinstance(results, list):
-                    return results[:5]  # Ensure max 5 results
+                    return results[:search_ret_len]  # Ensure max 5 results
             except (json.JSONDecodeError, ValueError):
                 try:
                     results = repair_json(results_text.strip())
                     if isinstance(results, list):
-                        return results[:5]  # Ensure max 5 results
+                        return results[:search_ret_len]  # Ensure max 5 results
                 except Exception as e:
-                    logger.warning(f"Failed to parse JSON from search results: {results_text}")
+                    logger.warning(f"Failed to parse JSON from LLM search results: {results_text}")
 
             # Fallback: return raw text as single result
             current_url = await browser_session.get_current_page_url()
@@ -866,6 +1117,74 @@ Return results as a JSON array: [{{"title": "...", "url": "...", "summary": "...
             logger.error(f"Google search failed for query '{query}': {e}")
             return []
 
+    def _rule_based_deduplication(self, results):
+        """Rule-based deduplication to reduce dataset before LLM processing"""
+        if not results:
+            return []
+        
+        deduplicated = []
+        seen_urls = set()
+        seen_titles = set()
+        
+        for result in results:
+            url = result.get('url', '').strip()
+            title = result.get('title', '').strip().lower()
+            
+            # Skip results with missing essential data
+            if not url or not title or url == 'No URL' or title == 'no title':
+                continue
+            
+            # Normalize URL for comparison (remove fragments, query params for deduplication)
+            normalized_url = url.split('#')[0].split('?')[0].lower()
+            
+            # Check for duplicate URLs
+            if normalized_url in seen_urls:
+                continue
+            
+            # Check for very similar titles (basic similarity)
+            title_normalized = ''.join(c for c in title if c.isalnum()).lower()
+            if len(title_normalized) > 10:  # Only check titles with substantial content
+                similar_found = False
+                for seen_title in seen_titles:
+                    # Simple similarity check: if 80% of characters match
+                    if len(title_normalized) > 0 and len(seen_title) > 0:
+                        common_chars = sum(1 for c in title_normalized if c in seen_title)
+                        similarity = common_chars / max(len(title_normalized), len(seen_title))
+                        if similarity > 0.8:
+                            similar_found = True
+                            break
+                
+                if similar_found:
+                    continue
+            
+            # Add to deduplicated results
+            seen_urls.add(normalized_url)
+            seen_titles.add(title_normalized)
+            deduplicated.append(result)
+        
+        # Sort by relevance indicators (prioritize results with longer summaries, non-generic titles)
+        def relevance_score(result):
+            score = 0
+            title = result.get('title', '')
+            summary = result.get('summary', '')
+            
+            # Longer summaries are typically more informative
+            score += min(len(summary), 200) / 10
+            
+            # Non-generic titles score higher
+            generic_terms = ['search results', 'no title', 'error', 'loading']
+            if not any(term in title.lower() for term in generic_terms):
+                score += 10
+            
+            # Prefer results with actual descriptions
+            if summary and summary != 'No description available' and len(summary) > 20:
+                score += 5
+                
+            return score
+        
+        deduplicated.sort(key=relevance_score, reverse=True)
+        return deduplicated
+
     async def _extract_structured_content(self, browser_session, query: str, llm: BaseChatModel):
         """Helper method to extract structured content from current page"""
         MAX_CHAR_LIMIT = 30000
@@ -1379,7 +1698,7 @@ You will be given a query and the markdown of a webpage that has been filtered t
         async def write_file(
                 file_path: str,
                 content: str,
-                file_system: FileSystem,
+                file_system: CustomFileSystem,
                 append: bool = False,
                 trailing_newline: bool = True,
                 leading_newline: bool = False,

vibe_surf/tools/views.py

@@ -178,3 +178,36 @@ class SkillCodeAction(BaseModel):
         max_length=4,
         description='Optional 4 character Tab ID to execute code on specific tab',
     )
+
+
+class SkillFinanceAction(BaseModel):
+    """Parameters for skill_finance action"""
+    symbol: str = Field(
+        description='Stock symbol to retrieve financial data for (e.g., AAPL, GOOG, TSLA)',
+    )
+    methods: list[str] | None = Field(
+        default=None,
+        description='List of finance methods to retrieve. Common methods: get_info (basic company info), get_history (stock price history), get_news (latest news), get_dividends (dividend history), get_earnings (earnings data), get_fast_info (quick stats), get_recommendations (analyst recommendations), get_financials (income statement), get_balance_sheet (balance sheet), get_cashflow (cash flow). If empty, defaults to get_info. Full list available in FinanceMethod enum.',
+    )
+    period: str = Field(
+        default='1y',
+        description='Time period for historical data (1d, 5d, 1mo, 3mo, 6mo, 1y, 2y, 5y, 10y, ytd, max)',
+    )
+    start_date: str | None = Field(
+        default=None,
+        description='Start date for historical data (YYYY-MM-DD format). Use with end_date instead of period.',
+    )
+    end_date: str | None = Field(
+        default=None,
+        description='End date for historical data (YYYY-MM-DD format). Use with start_date instead of period.',
+    )
+    interval: str = Field(
+        default='1d',
+        description='Data interval for historical data (1m, 2m, 5m, 15m, 30m, 60m, 90m, 1h, 1d, 5d, 1wk, 1mo, 3mo)',
+    )
+    num_news: int = Field(
+        default=5,
+        description='Number of news articles to retrieve when get_news method is selected',
+        ge=1,
+        le=20,
+    )

{vibesurf-0.1.23.dist-info → vibesurf-0.1.25.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vibesurf
-Version: 0.1.23
+Version: 0.1.25
 Summary: VibeSurf: A powerful browser assistant for vibe surfing
 Author: Shao Warm
 License: Apache-2.0
@@ -43,6 +43,7 @@ Requires-Dist: nanoid>=2.0.0
 Requires-Dist: markdownify>=1.2.0
 Requires-Dist: pathvalidate>=3.3.1
 Requires-Dist: dashscope>=1.24.5
+Requires-Dist: yfinance>=0.2.66
 Dynamic: license-file
 
 # VibeSurf: A powerful browser assistant for vibe surfing

{vibesurf-0.1.23.dist-info → vibesurf-0.1.25.dist-info}/RECORD

@@ -1,12 +1,12 @@
 vibe_surf/__init__.py,sha256=WtduuMFGauMD_9dpk4fnRnLTAP6ka9Lfu0feAFNzLfo,339
-vibe_surf/_version.py,sha256=eZj6tqY-zTtH5r_8y6a4Vovz6LQ_hDHSesTIiwuyahQ,706
+vibe_surf/_version.py,sha256=VIORluFSyo8DggJNI3m2ltXngK-bmCHX8hSwlGrwopY,706
 vibe_surf/cli.py,sha256=pbep2dBeQqralZ8AggkH4h2nayBarbdN8lhZxo35gNU,16689
 vibe_surf/common.py,sha256=_WWMxen5wFwzUjEShn3yDVC1OBFUiJ6Vccadi6tuG6w,1215
 vibe_surf/logger.py,sha256=k53MFA96QX6t9OfcOf1Zws8PP0OOqjVJfhUD3Do9lKw,3043
 vibe_surf/agents/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vibe_surf/agents/browser_use_agent.py,sha256=jeUYV7yk6vyycw6liju_597GdjB3CW_B2wEhn2F0ekk,45957
 vibe_surf/agents/report_writer_agent.py,sha256=pCF2k6VLyO-sSviGBqqIyVD3SLqaZtSqiW3kvNfPY1I,20967
-vibe_surf/agents/vibe_surf_agent.py,sha256=V1H7BquR0zIderpBw5ArY8d_6oLphSAxoiE6_ABTJyk,74301
+vibe_surf/agents/vibe_surf_agent.py,sha256=sTUO4xAiznr7RRzdrRYzXENos9XovicZw8ow2UuJsyI,74286
 vibe_surf/agents/views.py,sha256=yHjNJloa-aofVTGyuRy08tBYP_Y3XLqt1DUWOUmHRng,4825
 vibe_surf/agents/prompts/__init__.py,sha256=l4ieA0D8kLJthyNN85FKLNe4ExBa3stY3l-aImLDRD0,36
 vibe_surf/agents/prompts/report_writer_prompt.py,sha256=sZE8MUT1CDLmRzbnbEQzAvTwJjpITgh2Q8g1_eXmkzE,4454
@@ -20,7 +20,7 @@ vibe_surf/backend/api/__init__.py,sha256=XxF1jUOORpLYCfFuPrrnUGRnOrr6ClH0_MNPU-4
 vibe_surf/backend/api/activity.py,sha256=_cnHusqolt5Hf3KdAf6FK-3sBc-TSaadmb5dJxGI57A,9398
 vibe_surf/backend/api/agent.py,sha256=ISsG3FUIYoUCGcoQAfV3T6mtJSKHxC809p4bqjzjqlU,1199
 vibe_surf/backend/api/browser.py,sha256=NXedyZG3NIVRIx5O7d9mHwVWX-Q4_KsX5mSgfKt8UEA,2122
-vibe_surf/backend/api/config.py,sha256=EwzxYvC6HlaVo2OFWjtBmBMjX4eW2q8hp7l2LO2GZV0,27124
+vibe_surf/backend/api/config.py,sha256=vKY6ZnKZeazQP9qqUEiQvP9HoPtJbAzETORuPWZomGw,27272
 vibe_surf/backend/api/files.py,sha256=kJMG9MWECKXwGh64Q6xvAzNjeZGcLhIEnn65HiMZHKE,11762
 vibe_surf/backend/api/models.py,sha256=n_bu8vavvO8bIKA1WUAbaGPFeZKeamMJelDWU3DlFJc,10533
 vibe_surf/backend/api/task.py,sha256=vpQMOn6YBuD_16jzfUajUvBYaydC0jj8Ny3WOJDVuck,14359
@@ -36,7 +36,7 @@ vibe_surf/backend/database/migrations/v003_fix_task_status_case.sql,sha256=npzRg
 vibe_surf/backend/database/migrations/v004_add_voice_profiles.sql,sha256=-9arjQBF-OxvFIOwkEl7JJJRDTS_nJ8GNX3T7bJgVq0,1321
 vibe_surf/backend/utils/__init__.py,sha256=V8leMFp7apAglUAoCHPZrNNcRHthSLYIudIJE5qwjb0,184
 vibe_surf/backend/utils/encryption.py,sha256=CjLNh_n0Luhfa-6BB-icfzkiiDqj5b4Gu6MADU3p2eM,3754
-vibe_surf/backend/utils/llm_factory.py,sha256=mNy8o3sw7vYJ8gwiTsrgXbG7Ri_B11ylE4KGcfHULp8,8972
+vibe_surf/backend/utils/llm_factory.py,sha256=KF84YYgPaOF0_1P_IF0cAtY1kua0D-8gEP2NoSu2UZM,9033
 vibe_surf/browser/__init__.py,sha256=_UToO2fZfSCrfjOcxhn4Qq7ZLbYeyPuUUEmqIva-Yv8,325
 vibe_surf/browser/agen_browser_profile.py,sha256=J06hCBJSJ-zAFVM9yDFz8UpmiLuFyWke1EMekpU45eo,5871
 vibe_surf/browser/agent_browser_session.py,sha256=xV0nHo_TCb7b7QYhIee4cLzH-1rqJswYwH7GEwyQmqc,33980
@@ -85,19 +85,20 @@ vibe_surf/chrome_extension/styles/settings-responsive.css,sha256=jLE0yG15n2aI6_6
 vibe_surf/chrome_extension/styles/settings-utilities.css,sha256=3PuQS2857kg83d5erLbLdo_7J95-qV-qyNWS5M-w1oQ,505
 vibe_surf/chrome_extension/styles/variables.css,sha256=enjyhsa0PeU3b-3uiXa-VkV-1-h2-Ai3m4KpmC2k0rY,2984
 vibe_surf/llm/__init__.py,sha256=_vDVPo6STf343p1SgMQrF5023hicAx0g83pK2Gbk4Ek,601
-vibe_surf/llm/openai_compatible.py,sha256=8v0LW_-ZoKv4gcO--6_SmU_BLF8XCJaiPxZ6kXFgM4I,14998
+vibe_surf/llm/openai_compatible.py,sha256=rZfqjUggvftGGy76HQO3r3sumd2i_3iAuL52JyxkQUY,16113
 vibe_surf/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vibe_surf/tools/browser_use_tools.py,sha256=tacxKUJL6uOt04f52_iIw1cs-FT-mBgIPmAsIc4Hww0,23730
-vibe_surf/tools/file_system.py,sha256=PKRHe3EuOl78zzrA4SFiz1DDJotzx7OmszZqQMipQ-k,19317
+vibe_surf/tools/file_system.py,sha256=Tw_6J5QjCahQ3fd26CXziF1zPvRxhYM0889oK4bDhlU,19304
+vibe_surf/tools/finance_tools.py,sha256=E8rmblp57e_cp0tFbdZ7BY3_upNlk4Whk0bYc_SFCJE,27284
 vibe_surf/tools/mcp_client.py,sha256=OeCoTgyx4MoY7JxXndK6pGHIoyFOhf5r7XCbx25y1Ec,2446
-vibe_surf/tools/report_writer_tools.py,sha256=sUqUFr-_Rs8RJ0Bs77Hrp07kNwRIvHv7ErzSPYSlbTg,705
+vibe_surf/tools/report_writer_tools.py,sha256=2CyTTXOahTKZo7XwyWDDhJ--1mRA0uTtUWxu_DACAY0,776
 vibe_surf/tools/vibesurf_registry.py,sha256=Z-8d9BrJl3RFMEK0Tw1Q5xNHX2kZGsnIGCTBZ3RM-pw,2159
-vibe_surf/tools/vibesurf_tools.py,sha256=oeByep_Ud1V0n6pBayvLZJBUXch_iVVwOzUx8Rmsbqo,74350
-vibe_surf/tools/views.py,sha256=QyOjbEL4VwJvyFnYytP6r-Nju9ufvrAllSK2U8kwrGU,6183
+vibe_surf/tools/vibesurf_tools.py,sha256=USmSqSc03h-FsuzvOcN_S8f3hHVJ-WEx0V5V8RxskoE,90101
+vibe_surf/tools/views.py,sha256=AEAPzML-lqWJ7dBMjXTl7o-rk4hp5PGaPRqLyilJUl8,7789
 vibe_surf/tools/voice_asr.py,sha256=AJG0yq_Jq-j8ulDlbPhVFfK1jch9_ASesis73iki9II,4702
-vibesurf-0.1.23.dist-info/licenses/LICENSE,sha256=czn6QYya0-jhLnStD9JqnMS-hwP5wRByipkrGTvoXLI,11355
-vibesurf-0.1.23.dist-info/METADATA,sha256=De_G65fKEOpXevnlZu6IEyQ8W4F1KoxIif2yn8CJjqk,5158
-vibesurf-0.1.23.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-vibesurf-0.1.23.dist-info/entry_points.txt,sha256=UxqpvMocL-PR33S6vLF2OmXn-kVzM-DneMeZeHcPMM8,48
-vibesurf-0.1.23.dist-info/top_level.txt,sha256=VPZGHqSb6EEqcJ4ZX6bHIuWfon5f6HXl3c7BYpbRqnY,10
-vibesurf-0.1.23.dist-info/RECORD,,
+vibesurf-0.1.25.dist-info/licenses/LICENSE,sha256=czn6QYya0-jhLnStD9JqnMS-hwP5wRByipkrGTvoXLI,11355
+vibesurf-0.1.25.dist-info/METADATA,sha256=cplQA5KwaRfM0Hy8l7TFXjkxsxmF-xyL2WbJWZ7FOUg,5190
+vibesurf-0.1.25.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+vibesurf-0.1.25.dist-info/entry_points.txt,sha256=UxqpvMocL-PR33S6vLF2OmXn-kVzM-DneMeZeHcPMM8,48
+vibesurf-0.1.25.dist-info/top_level.txt,sha256=VPZGHqSb6EEqcJ4ZX6bHIuWfon5f6HXl3c7BYpbRqnY,10
+vibesurf-0.1.25.dist-info/RECORD,,