semantio 0.0.2__py3-none-any.whl → 0.0.4__py3-none-any.whl

semantio/agent.py

@@ -21,24 +21,24 @@ import os
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-class Assistant(BaseModel):
+class Agent(BaseModel):
     # -*- Agent settings
-    name: Optional[str] = Field(None, description="Name of the assistant.")
-    description: Optional[str] = Field(None, description="Description of the assistant's role.")
-    instructions: Optional[List[str]] = Field(None, description="List of instructions for the assistant.")
+    name: Optional[str] = Field(None, description="Name of the agent.")
+    description: Optional[str] = Field(None, description="Description of the agent's role.")
+    instructions: Optional[List[str]] = Field(None, description="List of instructions for the agent.")
     model: Optional[str] = Field(None, description="This one is not in the use.")
     show_tool_calls: bool = Field(False, description="Whether to show tool calls in the response.")
     markdown: bool = Field(False, description="Whether to format the response in markdown.")
-    tools: Optional[List[BaseTool]] = Field(None, description="List of tools available to the assistant.")
-    user_name: Optional[str] = Field("User", description="Name of the user interacting with the assistant.")
-    emoji: Optional[str] = Field(":robot:", description="Emoji to represent the assistant in the CLI.")
+    tools: Optional[List[BaseTool]] = Field(None, description="List of tools available to the agent.")
+    user_name: Optional[str] = Field("User", description="Name of the user interacting with the agent.")
+    emoji: Optional[str] = Field(":robot:", description="Emoji to represent the agent in the CLI.")
     rag: Optional[RAG] = Field(None, description="RAG instance for context retrieval.")
     knowledge_base: Optional[Any] = Field(None, description="Knowledge base for domain-specific information.")
     llm: Optional[str] = Field(None, description="The LLM provider to use (e.g., 'groq', 'openai', 'anthropic').")
     llm_model: Optional[str] = Field(None, description="The specific model to use for the LLM provider.")
     llm_instance: Optional[BaseLLM] = Field(None, description="The LLM instance to use.")
     json_output: bool = Field(False, description="Whether to format the response as JSON.")
-    api: bool = Field(False, description="Whether to generate an API for the assistant.")
+    api: bool = Field(False, description="Whether to generate an API for the agent.")
     api_config: Optional[Dict] = Field(
         None,
         description="Configuration for the API (e.g., host, port, authentication).",
@@ -46,7 +46,7 @@ class Assistant(BaseModel):
     api_generator: Optional[Any] = Field(None, description="The API generator instance.")
     expected_output: Optional[Union[str, Dict]] = Field(None, description="The expected format or structure of the output.")
     semantic_model: Optional[Any] = Field(None, description="SentenceTransformer model for semantic matching.")
-    team: Optional[List['Assistant']] = Field(None, description="List of assistants in the team.")
+    team: Optional[List['Agent']] = Field(None, description="List of assistants in the team.")
     auto_tool: bool = Field(False, description="Whether to automatically detect and call tools.")
     
     # Allow arbitrary types
@@ -56,8 +56,11 @@ class Assistant(BaseModel):
         super().__init__(**kwargs)
         # Initialize the model and tools here if needed
         self._initialize_model()
-        # Automatically discover and register tools if not provided
+        # Initialize tools as an empty list if not provided
         if self.tools is None:
+            self.tools = []
+        # Automatically discover and register tools if auto tool is enabled
+        if self.auto_tool and not self.tools:
             self.tools = self._discover_tools()
         # Pass the LLM instance to each tool
         for tool in self.tools:
@@ -125,7 +128,7 @@ class Assistant(BaseModel):
             try:
                 # Import the module
                 module_name = file.stem
-                module = importlib.import_module(f"hashai.tools.{module_name}")
+                module = importlib.import_module(f"semantio.tools.{module_name}")
 
                 # Find all classes that inherit from BaseTool
                 for name, obj in module.__dict__.items():
@@ -197,7 +200,7 @@ class Assistant(BaseModel):
         model_to_use = self.llm_model or default_model
 
         # Dynamically import and initialize the LLM class
-        module_name = f"hashai.llm.{llm_provider}"
+        module_name = f"semantio.llm.{llm_provider}"
         llm_module = importlib.import_module(module_name)
         llm_class = getattr(llm_module, llm_class_name)
         self.llm_instance = llm_class(model=model_to_use, api_key=api_key)
@@ -213,11 +216,10 @@ class Assistant(BaseModel):
         message: Optional[Union[str, Image, List, Dict]] = None,
         stream: bool = False,
         markdown: bool = False,
-        tools: Optional[List[BaseTool]] = None,
-        team: Optional[List['Assistant']] = None,
+        team: Optional[List['Agent']] = None,
         **kwargs,
     ) -> Union[str, Dict]:  # Add return type hint
-        """Print the assistant's response to the console and return it."""
+        """Print the agent's response to the console and return it."""
 
         if stream:
             # Handle streaming response
@@ -228,60 +230,23 @@ class Assistant(BaseModel):
             return response
         else:
             # Generate and return the response
-            response = self._generate_response(message, markdown=markdown, tools=tools, team=team, **kwargs)
+            response = self._generate_response(message, markdown=markdown, team=team, **kwargs)
             print(response)  # Print the response to the console
             return response
 
 
     def _stream_response(self, message: str, markdown: bool = False, **kwargs) -> Iterator[str]:
-        """Stream the assistant's response."""
+        """Stream the agent's response."""
         # Simulate streaming by yielding chunks of the response
         response = self._generate_response(message, markdown=markdown, **kwargs)
         for chunk in response.split():
             yield chunk + " "
 
     def register_tool(self, tool: BaseTool):
-        """Register a tool for the assistant."""
+        """Register a tool for the agent."""
         if self.tools is None:
             self.tools = []
         self.tools.append(tool)
-
-    def _detect_tool_call(self, message: str) -> Optional[Dict[str, Any]]:
-        """
-        Use the LLM to detect which tool should be called based on the user's query.
-        """
-        if not self.tools:
-            logger.warning("No tools available to detect.")
-            return None
-
-        # Create a prompt for the LLM
-        prompt = f"""
-        You are an AI assistant that helps users by selecting the most appropriate tool to answer their query. Below is a list of available tools and their functionalities:
-
-        {self._get_tool_descriptions()}
-
-        Based on the user's query, select the most appropriate tool. Respond with the name of the tool (e.g., "CryptoPriceChecker"). If no tool is suitable, respond with "None".
-
-        User Query: "{message}"
-        """
-
-        try:
-            # Call the LLM to generate the response
-            response = self.llm_instance.generate(prompt=prompt)
-            tool_name = response.strip().replace('"', '').replace("'", "")
-
-            # Find the tool in the list of available tools
-            tool = next((t for t in self.tools if t.name.lower() == tool_name.lower()), None)
-            if tool:
-                logger.info(f"Detected tool call: {tool.name}")
-                return {
-                    "tool": tool.name,
-                    "input": {"query": message}
-                }
-        except Exception as e:
-            logger.error(f"Failed to detect tool call: {e}")
-
-        return None
     
     def _analyze_query_and_select_tools(self, query: str) -> List[Dict[str, Any]]:
         """
@@ -290,7 +255,7 @@ class Assistant(BaseModel):
         """
         # Create a prompt for the LLM to analyze the query and select tools
         prompt = f"""
-        You are an AI assistant that helps analyze user queries and select the most appropriate tools.
+        You are an AI agent that helps analyze user queries and select the most appropriate tools.
         Below is a list of available tools and their functionalities:
 
         {self._get_tool_descriptions()}
@@ -324,17 +289,16 @@ class Assistant(BaseModel):
             return []
     
 
-    def _generate_response(self, message: str, markdown: bool = False, tools: Optional[List[BaseTool]] = None, team: Optional[List['Assistant']] = None, **kwargs) -> str:
-        """Generate the assistant's response, including tool execution and context retrieval."""
-        # Use the specified tools or team if provided
-        if tools is not None:
-            self.tools = tools
+    def _generate_response(self, message: str, markdown: bool = False, team: Optional[List['Agent']] = None, **kwargs) -> str:
+        """Generate the agent's response, including tool execution and context retrieval."""
+        # Use the specified team if provided
         if team is not None:
             return self._generate_team_response(message, team, markdown=markdown, **kwargs)
 
         # Initialize tool_outputs as an empty dictionary
         tool_outputs = {}
         responses = []
+        tool_calls = []
 
         # Use the LLM to analyze the query and dynamically select tools when auto_tool is enabled
         if self.auto_tool:
@@ -344,7 +308,7 @@ class Assistant(BaseModel):
             if self.tools:
                 tool_calls = [
                     {
-                        "tool": tool.__class__.__name__,
+                        "tool": tool.name,
                         "input": {
                             "query": message,  # Use the message as the query
                             "context": None,  # No context provided by default
@@ -352,10 +316,8 @@ class Assistant(BaseModel):
                     }
                     for tool in self.tools
                 ]
-            else:
-                tool_calls = kwargs.get("tool_calls", [])
 
-            # Execute tools if any are detected
+        # Execute tools if any are detected
         if tool_calls:
             for tool_call in tool_calls:
                 tool_name = tool_call["tool"]
@@ -396,7 +358,7 @@ class Assistant(BaseModel):
             except Exception as e:
                 logger.error(f"Failed to generate LLM response: {e}")
                 responses.append(f"An error occurred while generating the analysis: {e}")
-        if not tool_calls:
+        if not self.tools and not tool_calls:
             # If no tools were executed, proceed with the original logic
             # Retrieve relevant context using RAG
             rag_context = self.rag.retrieve(message) if self.rag else None
@@ -435,12 +397,12 @@ class Assistant(BaseModel):
         # Combine all responses into a single string
         return "\n\n".join(responses)
     
-    def _generate_team_response(self, message: str, team: List['Assistant'], markdown: bool = False, **kwargs) -> str:
+    def _generate_team_response(self, message: str, team: List['Agent'], markdown: bool = False, **kwargs) -> str:
         """Generate a response using a team of assistants."""
         responses = []
-        for assistant in team:
-            response = assistant.print_response(message, markdown=markdown, **kwargs)
-            responses.append(f"**{assistant.name}:**\n\n{response}")
+        for agent in team:
+            response = agent.print_response(message, markdown=markdown, **kwargs)
+            responses.append(f"**{agent.name}:**\n\n{response}")
         return "\n\n".join(responses)
 
     def _build_prompt(self, message: str, context: Optional[List[Dict]]) -> str:
@@ -578,7 +540,7 @@ class Assistant(BaseModel):
         exit_on: Optional[List[str]] = None,
         **kwargs,
     ):
-        """Run the assistant in a CLI app."""
+        """Run the agent in a CLI app."""
         from rich.prompt import Prompt
 
         if message:
@@ -593,15 +555,15 @@ class Assistant(BaseModel):
             self.print_response(message=message, **kwargs)
 
     def _generate_api(self):
-        """Generate an API for the assistant if api=True."""
+        """Generate an API for the agent if api=True."""
         from .api.api_generator import APIGenerator
         self.api_generator = APIGenerator(self)
-        print(f"API generated for assistant '{self.name}'. Use `.run_api()` to start the API server.")
+        print(f"API generated for agent '{self.name}'. Use `.run_api()` to start the API server.")
 
     def run_api(self):
-        """Run the API server for the assistant."""
+        """Run the API server for the agent."""
         if not hasattr(self, 'api_generator'):
-            raise ValueError("API is not enabled for this assistant. Set `api=True` when initializing the assistant.")
+            raise ValueError("API is not enabled for this agent. Set `api=True` when initializing the agent.")
     
         # Get API configuration
         host = self.api_config.get("host", "0.0.0.0") if self.api_config else "0.0.0.0"

semantio/cli/main.py

@@ -1,7 +1,7 @@
 import argparse
 import warnings
-from hashai.assistant import Assistant
-from hashai.llm import get_llm
+from semantio.agent import Agent
+from semantio.llm import get_llm
 from urllib3.exceptions import NotOpenSSLWarning
 
 # Suppress the NotOpenSSLWarning
@@ -9,7 +9,7 @@ warnings.filterwarnings("ignore", category=NotOpenSSLWarning)
 
 def main():
     parser = argparse.ArgumentParser(description="opAi CLI")
-    parser.add_argument("--message", type=str, required=True, help="Message to send to the assistant")
+    parser.add_argument("--message", type=str, required=True, help="Message to send to the agent")
     parser.add_argument("--provider", type=str, required=True, help="LLM provider (e.g., groq, openai)")
     parser.add_argument("--api-key", type=str, required=True, help="API key for the LLM provider")
     parser.add_argument("--model", type=str, default=None, help="Model name (e.g., mixtral-8x7b-32768)")
@@ -22,9 +22,9 @@ def main():
 
     llm = get_llm(provider=args.provider, **llm_config)
 
-    # Create an assistant
-    assistant = Assistant(model=args.provider, llm=llm)
-    assistant.print_response(args.message)
+    # Create an agent
+    agent = Agent(model=args.provider, llm=llm)
+    agent.print_response(args.message)
     
 
 if __name__ == "__main__":

semantio/tools/web_browser.py

@@ -1,153 +1,271 @@
-from typing import Dict, Any, Optional, List
-from playwright.async_api import async_playwright
-import asyncio
+# web_browser.py
+from typing import Dict, Any, List, Optional
+from pydantic import Field, BaseModel
+from selenium import webdriver
+from selenium.webdriver.common.by import By
+from selenium.webdriver.support.ui import WebDriverWait
+from selenium.webdriver.support import expected_conditions as EC
+from selenium.webdriver.chrome.options import Options
+from selenium.webdriver.chrome.service import Service
+from webdriver_manager.chrome import ChromeDriverManager
+from bs4 import BeautifulSoup
+import json
+import time
+import re
 import logging
+from .base_tool import BaseTool
 
 logger = logging.getLogger(__name__)
 
-class WebBrowserTool:
-    """
-    A tool for performing browser automation tasks using Playwright.
-    """
+class BrowserPlan(BaseModel):
+    tasks: List[Dict[str, Any]] = Field(
+        ...,
+        description="List of automation tasks to execute"
+    )
 
-    def __init__(self, headless: bool = True):
-        """
-        Initialize the WebBrowserTool.
-
-        Args:
-            headless (bool): Whether to run the browser in headless mode (default: True).
-        """
-        self.headless = headless
-        self.browser = None
-        self.context = None
-        self.page = None
-
-    async def start(self):
-        """
-        Start the browser and create a new context and page.
-        """
-        self.playwright = await async_playwright().start()
-        self.browser = await self.playwright.chromium.launch(headless=self.headless)
-        self.context = await self.browser.new_context()
-        self.page = await self.context.new_page()
-        logger.info("Browser started successfully.")
-
-    async def close(self):
-        """
-        Close the browser and cleanup resources.
-        """
-        if self.browser:
-            await self.browser.close()
-        await self.playwright.stop()
-        logger.info("Browser closed successfully.")
-
-    async def navigate(self, url: str) -> str:
-        """
-        Navigate to a specific URL.
-
-        Args:
-            url (str): The URL to navigate to.
-
-        Returns:
-            str: The page title after navigation.
-        """
-        if not self.page:
-            raise RuntimeError("Browser is not started. Call start() first.")
-
-        await self.page.goto(url)
-        title = await self.page.title()
-        logger.info(f"Navigated to {url}. Page title: {title}")
-        return title
-
-    async def fill_form(self, fields: Dict[str, str]) -> str:
-        """
-        Fill a form with the provided fields.
-
-        Args:
-            fields (Dict[str, str]): A dictionary of field names and values to fill.
-
-        Returns:
-            str: A success message.
-        """
-        if not self.page:
-            raise RuntimeError("Browser is not started. Call start() first.")
-
-        for field, value in fields.items():
-            await self.page.fill(f'input[name="{field}"]', value)
-            logger.info(f"Filled field '{field}' with value '{value}'.")
-
-        return "Form filled successfully."
-
-    async def click(self, selector: str) -> str:
-        """
-        Click an element on the page.
-
-        Args:
-            selector (str): The CSS selector of the element to click.
-
-        Returns:
-            str: A success message.
-        """
-        if not self.page:
-            raise RuntimeError("Browser is not started. Call start() first.")
+class WebBrowserTool(BaseTool):
+    name: str = Field("WebBrowser", description="Name of the tool")
+    description: str = Field(
+        "Universal web automation tool for dynamic website interactions",
+        description="Tool description"
+    )
+    
+    def execute(self, input: Dict[str, Any]) -> Dict[str, Any]:
+        """Execute dynamic web automation workflow"""
+        driver = None
+        try:
+            driver = self._init_browser(input.get("headless", False))
+            results = []
+            current_url = ""
 
-        await self.page.click(selector)
-        logger.info(f"Clicked element with selector '{selector}'.")
-        return f"Clicked element: {selector}"
+            # Generate initial plan
+            plan = self._generate_plan(input['query'], current_url)
+            
+            for task in plan.tasks:
+                result = self._execute_safe_task(driver, task)
+                results.append(result)
+                
+                if not result['success']:
+                    break
+                    
+                # Update context for next tasks
+                current_url = driver.current_url
 
-    async def scrape(self, selector: str) -> List[Dict[str, str]]:
-        """
-        Scrape data from the page.
+            return {"status": "success", "results": results}
+            
+        except Exception as e:
+            return {"status": "error", "message": str(e)}
+        finally:
+            if driver:
+                driver.quit()
 
-        Args:
-            selector (str): The CSS selector of the elements to scrape.
+    def _init_browser(self, headless: bool) -> webdriver.Chrome:
+        """Initialize browser with advanced options"""
+        options = Options()
+        options.add_argument("--start-maximized")
+        options.add_argument("--disable-blink-features=AutomationControlled")
+        options.add_experimental_option("excludeSwitches", ["enable-automation"])
+        
+        if headless:
+            options.add_argument("--headless=new")
+            
+        return webdriver.Chrome(
+            service=Service(ChromeDriverManager().install()),
+            options=options
+        )
 
-        Returns:
-            List[Dict[str, str]]: A list of dictionaries containing the scraped data.
+    def _generate_plan(self, query: str, current_url: str) -> BrowserPlan:
+        """Generate adaptive execution plan using LLM"""
+        prompt = f"""Generate browser automation plan for: {query}
+        
+        Current URL: {current_url or 'No page loaded yet'}
+        
+        Required JSON format:
+        {{
+            "tasks": [
+                {{
+                    "action": "navigate|click|type|wait|scroll",
+                    "selector": "CSS selector (optional)",
+                    "value": "input text/URL/seconds",
+                    "description": "action purpose"
+                }}
+            ]
+        }}
+        
+        Guidelines:
+        1. Prefer IDs in selectors (#element-id)
+        2. Use semantic attributes (aria-label, name)
+        3. Include wait steps after navigation
+        4. Prioritize visible elements
+        5. Add scroll steps for hidden elements
         """
-        if not self.page:
-            raise RuntimeError("Browser is not started. Call start() first.")
+        
+        response = self.llm.generate(prompt=prompt)
+        return self._parse_plan(response)
 
-        elements = await self.page.query_selector_all(selector)
-        scraped_data = []
-        for element in elements:
-            text = await element.inner_text()
-            scraped_data.append({"text": text.strip()})
-            logger.info(f"Scraped text: {text.strip()}")
+    def _parse_plan(self, response: str) -> BrowserPlan:
+        """Robust JSON parsing with multiple fallback strategies"""
+        try:
+            # Try extracting JSON from markdown code block
+            json_match = re.search(r'```json\n?(.+?)\n?```', response, re.DOTALL)
+            if json_match:
+                plan_data = json.loads(json_match.group(1).strip())
+            else:
+                # Fallback to extract first JSON object
+                json_str = re.search(r'\{.*\}', response, re.DOTALL).group()
+                plan_data = json.loads(json_str)
+            
+            # Validate tasks structure
+            validated_tasks = []
+            for task in plan_data.get("tasks", []):
+                if not all(key in task for key in ["action", "description"]):
+                    continue
+                validated_tasks.append({
+                    "action": task["action"],
+                    "selector": task.get("selector", ""),
+                    "value": task.get("value", ""),
+                    "description": task["description"]
+                })
+            
+            return BrowserPlan(tasks=validated_tasks)
+            
+        except (json.JSONDecodeError, AttributeError) as e:
+            logger.error(f"Plan parsing failed: {e}")
+            return BrowserPlan(tasks=[])
 
-        return scraped_data
+    def _execute_safe_task(self, driver, task: Dict) -> Dict[str, Any]:
+        """Execute task with comprehensive error handling"""
+        try:
+            action = task["action"].lower()
+            selector = task.get("selector", "")
+            value = task.get("value", "")
+            
+            if action == "navigate":
+                return self._handle_navigation(driver, value)
+                
+            elif action == "click":
+                return self._handle_click(driver, selector)
+                
+            elif action == "type":
+                return self._handle_typing(driver, selector, value)
+                
+            elif action == "wait":
+                return self._handle_wait(value)
+                
+            elif action == "scroll":
+                return self._handle_scroll(driver, selector)
+                
+            return {
+                "action": action,
+                "success": False,
+                "message": f"Unsupported action: {action}"
+            }
+            
+        except Exception as e:
+            return {
+                "action": action,
+                "success": False,
+                "message": f"Critical error: {str(e)}"
+            }
 
-    async def execute_step(self, step: Dict[str, Any]) -> str:
-        """
-        Execute a browser automation step.
+    def _handle_navigation(self, driver, url: str) -> Dict[str, Any]:
+        """Smart navigation handler"""
+        if not url.startswith(("http://", "https://")):
+            url = f"https://{url}"
+            
+        try:
+            driver.get(url)
+            WebDriverWait(driver, 15).until(
+                EC.presence_of_element_located((By.TAG_NAME, "body"))
+            )
+            return {
+                "action": "navigate",
+                "success": True,
+                "message": f"Navigated to {url}"
+            }
+        except Exception as e:
+            return {
+                "action": "navigate",
+                "success": False,
+                "message": f"Navigation failed: {str(e)}"
+            }
 
-        Args:
-            step (Dict[str, Any]): A dictionary containing the step details.
-                - "action": The action to perform (e.g., "navigate", "fill_form", "click", "scrape").
-                - "details": The details required for the action (e.g., URL, form fields, selector).
-                - "website": The website to perform the action on (optional).
+    def _handle_click(self, driver, selector: str) -> Dict[str, Any]:
+        """Dynamic click handler"""
+        try:
+            element = WebDriverWait(driver, 15).until(
+                EC.element_to_be_clickable((By.CSS_SELECTOR, selector))
+            )
+            driver.execute_script("arguments[0].scrollIntoView({behavior: 'smooth'});", element)
+            element.click()
+            return {
+                "action": "click",
+                "success": True,
+                "message": f"Clicked element: {selector}"
+            }
+        except Exception as e:
+            return {
+                "action": "click",
+                "success": False,
+                "message": f"Click failed: {str(e)}"
+            }
 
-        Returns:
-            str: The result of the step execution.
-        """
-        action = step.get("action")
-        details = step.get("details")
-        website = step.get("website", "https://www.google.com")
+    def _handle_typing(self, driver, selector: str, text: str) -> Dict[str, Any]:
+        """Universal typing handler"""
+        try:
+            element = WebDriverWait(driver, 15).until(
+                EC.presence_of_element_located((By.CSS_SELECTOR, selector))
+            )
+            element.clear()
+            element.send_keys(text)
+            return {
+                "action": "type",
+                "success": True,
+                "message": f"Typed '{text}' into {selector}"
+            }
+        except Exception as e:
+            return {
+                "action": "type",
+                "success": False,
+                "message": f"Typing failed: {str(e)}"
+            }
 
-        if not self.page:
-            await self.start()
+    def _handle_wait(self, seconds: str) -> Dict[str, Any]:
+        """Configurable wait handler"""
+        try:
+            wait_time = float(seconds)
+            time.sleep(wait_time)
+            return {
+                "action": "wait",
+                "success": True,
+                "message": f"Waited {wait_time} seconds"
+            }
+        except ValueError:
+            return {
+                "action": "wait",
+                "success": False,
+                "message": "Invalid wait time"
+            }
 
+    def _handle_scroll(self, driver, selector: str) -> Dict[str, Any]:
+        """Smart scroll handler"""
         try:
-            if action == "navigate":
-                return await self.navigate(details)
-            elif action == "fill_form":
-                return await self.fill_form(details)
-            elif action == "click":
-                return await self.click(details)
-            elif action == "scrape":
-                return str(await self.scrape(details))
+            if selector:
+                element = WebDriverWait(driver, 15).until(
+                    EC.presence_of_element_located((By.CSS_SELECTOR, selector))
+                )
+                driver.execute_script("arguments[0].scrollIntoView({behavior: 'smooth'});", element)
             else:
-                return f"Unknown action: {action}"
+                driver.execute_script("window.scrollTo(0, document.body.scrollHeight);")
+                
+            return {
+                "action": "scroll",
+                "success": True,
+                "message": f"Scrolled to {selector or 'page bottom'}"
+            }
         except Exception as e:
-            logger.error(f"Error executing step: {e}")
-            return f"Error executing step: {e}"
+            return {
+                "action": "scroll",
+                "success": False,
+                "message": f"Scroll failed: {str(e)}"
+            }

{semantio-0.0.2.dist-info → semantio-0.0.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: semantio
-Version: 0.0.2
+Version: 0.0.4
 Summary: A powerful SDK for building AI agents
 Home-page: https://github.com/Syenah/semantio
 Author: Rakesh
@@ -33,6 +33,10 @@ Requires-Dist: sentence-transformers
 Requires-Dist: fuzzywuzzy
 Requires-Dist: duckduckgo-search
 Requires-Dist: yfinance
+Requires-Dist: selenium
+Requires-Dist: beautifulsoup4
+Requires-Dist: webdriver-manager
+Requires-Dist: validators
 
 # Semantio: The Mother of Your AI Agents
 

{semantio-0.0.2.dist-info → semantio-0.0.4.dist-info}/RECORD

@@ -1,12 +1,12 @@
 semantio/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-semantio/agent.py,sha256=mwcKaHy-HY26hxgCRZS5LZw1semlj59qF4uYcLpyqBc,30247
+semantio/agent.py,sha256=hKytSI5LqNnxqVvwI2hOINqPgrdhUXY9MS_90_crZPs,28584
 semantio/memory.py,sha256=eNAwyAokppHzMcIyFgOw2hT2wnLQBd9GL4T5eallNV4,281
 semantio/rag.py,sha256=ROy3Pa1NURcDs6qQZ8IMoa5Xlzt6I-msEq0C1p8UgB0,472
 semantio/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 semantio/api/api_generator.py,sha256=Q-USITEpluRESEaQuOmF7m1vhLKYU9P8eGlQppKT9J4,829
 semantio/api/fastapi_app.py,sha256=DyTgKJKikMe2G6wWmyzo1rBLXQFi8UWWUMY3UGH4f24,2128
 semantio/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-semantio/cli/main.py,sha256=BvY2B2xUSV1Q-4K6eH5P1tJB2Y0aL_rm-1ZW-D0F3eU,1115
+semantio/cli/main.py,sha256=jUvSfehbHWALwracEgBopMIVMraSV9QmDUFfgGcxnP0,1091
 semantio/knowledge_base/__init__.py,sha256=mvp0GFiGSjcxlkaDulAwKOCL9s6gsKTqhPKXF9N3n1g,172
 semantio/knowledge_base/document_loader.py,sha256=nix0yZJ-JJoDbhLkpg5bKDMvNrwykmknI7MRIn0N81k,1910
 semantio/knowledge_base/retriever.py,sha256=XpdzKS1UCncJImVMtG67VXMC7lp2eRzKnShjvktsFMM,1271
@@ -17,7 +17,6 @@ semantio/llm/base_llm.py,sha256=VFl_2S4kqYDuCTWIfWMbKU5aNbVqOCG33E4APOSHF90,668
 semantio/llm/deepseek.py,sha256=oxX-Uw0_lY2sstYs5KGBGFB_hAZUbZomPADdib1mY2M,1100
 semantio/llm/gemini.py,sha256=er3zv1jOvWQBGbPuv4fS4pR_c_abHyhroe-rkXupOO4,1959
 semantio/llm/groq.py,sha256=1AH30paKzDIQjBjWPQPN44QwFHsIOVwI-a587-cDIVc,4285
-semantio/llm/llama.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 semantio/llm/mistral.py,sha256=NpvaB1cE6-jMEBdT0mTf6Ca4Qq2LS8QivDKI6AgdRjE,1061
 semantio/llm/openai.py,sha256=I3ab-d_zFxm-TDhYk6t1PzDtElPJEEQ2eSiARBNIGi4,5174
 semantio/storage/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -28,16 +27,16 @@ semantio/tools/base_tool.py,sha256=xBNSa_8a8WmA4BGRLG2dE7wj9GnBcZo7-P2SyD86GvY,5
 semantio/tools/crypto.py,sha256=mut1ztvpPcUUP3b563dh_FmKtP68KmNis3Qm8WENj8w,5559
 semantio/tools/duckduckgo.py,sha256=6mGn0js0cIsVxQlAgB8AYNLP05H8WmJKnSVosiO9iH0,5034
 semantio/tools/stocks.py,sha256=BVuK61O9OmWQjj0YdiCJY6TzpiFJ_An1UJB2RkDfX2k,5393
-semantio/tools/web_browser.py,sha256=LMwPFTHNTtqCp8MEHVlJJUSJa91vM7MZWIL5RDQKF4U,4980
+semantio/tools/web_browser.py,sha256=wqr5pj2GybkK9IHDb8C1BipS8ujV2l36WlwA8ZbKd88,9711
 semantio/utils/__init__.py,sha256=Lx4X4iJpRhZzRmpQb80XXh5Ve8ZMOkadWAxXSmHpO_8,244
 semantio/utils/config.py,sha256=ZTwUTqxjW3-w94zoU7GzivWyJe0JJGvBfuB4RUOuEs8,1198
 semantio/utils/date_utils.py,sha256=x3oqRGv6ee_KCJ0LvCqqZh_FSgS6YGOHBwZQS4TJetY,1471
 semantio/utils/file_utils.py,sha256=b_cMuJINEGk9ikNuNHSn9lsmICWwvtnCDZ03ndH_S2I,1779
 semantio/utils/logger.py,sha256=TmGbP8BRjLMWjXi2GWzZ0RIXt70x9qX3FuIqghCNlwM,510
 semantio/utils/validation_utils.py,sha256=iwoxEb4Q5ILqV6tbesMjPWPCCoL3AmPLejGUy6q8YvQ,1284
-semantio-0.0.2.dist-info/LICENSE,sha256=teQbWD2Zlcl1_Fo29o2tNbs6G26hbCQiUzds5fQGYlY,1063
-semantio-0.0.2.dist-info/METADATA,sha256=LsBDOM1gPw6rbzZ_-TIf4XJxf3DEWZ7s8KDd8_cDMw0,6800
-semantio-0.0.2.dist-info/WHEEL,sha256=ewwEueio1C2XeHTvT17n8dZUJgOvyCWCt0WVNLClP9o,92
-semantio-0.0.2.dist-info/entry_points.txt,sha256=zbPgevSLwcLpdRHqI_atE8EOt8lK2vRF1AoDflDTo18,53
-semantio-0.0.2.dist-info/top_level.txt,sha256=Yte_6mb-bh-I_lQwMjk1GijZkxPoX4Zmp3kBftC1ZlA,9
-semantio-0.0.2.dist-info/RECORD,,
+semantio-0.0.4.dist-info/LICENSE,sha256=teQbWD2Zlcl1_Fo29o2tNbs6G26hbCQiUzds5fQGYlY,1063
+semantio-0.0.4.dist-info/METADATA,sha256=youxODbkR3gNERG-mD7zbUbe5ix-0lUiWCHUI1_Y5IY,6913
+semantio-0.0.4.dist-info/WHEEL,sha256=ewwEueio1C2XeHTvT17n8dZUJgOvyCWCt0WVNLClP9o,92
+semantio-0.0.4.dist-info/entry_points.txt,sha256=zbPgevSLwcLpdRHqI_atE8EOt8lK2vRF1AoDflDTo18,53
+semantio-0.0.4.dist-info/top_level.txt,sha256=Yte_6mb-bh-I_lQwMjk1GijZkxPoX4Zmp3kBftC1ZlA,9
+semantio-0.0.4.dist-info/RECORD,,