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

semantio/__init__.py

@@ -0,0 +1,4 @@
+import warnings
+
+# Suppress all warnings globally
+warnings.simplefilter("ignore")

semantio/agent.py

@@ -16,6 +16,7 @@ from .tools.base_tool import BaseTool
 from pathlib import Path
 import importlib
 import os
+from .memory import Memory
 
 # Configure logging
 logging.basicConfig(level=logging.INFO)
@@ -48,6 +49,13 @@ class Agent(BaseModel):
     semantic_model: Optional[Any] = Field(None, description="SentenceTransformer model for semantic matching.")
     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.")
+    memory: Memory = Field(default_factory=Memory)
+    memory_config: Dict = Field(
+        default_factory=lambda: {
+            "max_context_length": 4000,
+            "summarization_threshold": 3000
+        }
+    )
     
     # Allow arbitrary types
     model_config = ConfigDict(arbitrary_types_allowed=True)
@@ -56,6 +64,11 @@ class Agent(BaseModel):
         super().__init__(**kwargs)
         # Initialize the model and tools here if needed
         self._initialize_model()
+        # Initialize memory with config
+        self.memory = Memory(
+            max_context_length=self.memory_config.get("max_context_length", 4000),
+            summarization_threshold=self.memory_config.get("summarization_threshold", 3000)
+        )
         # Initialize tools as an empty list if not provided
         if self.tools is None:
             self.tools = []
@@ -218,20 +231,31 @@ class Agent(BaseModel):
         markdown: bool = False,
         team: Optional[List['Agent']] = None,
         **kwargs,
-    ) -> Union[str, Dict]:  # Add return type hint
+    ) -> Union[str, Dict]:
         """Print the agent's response to the console and return it."""
+    
+        # Store user message if provided
+        if message and isinstance(message, str):
+            self.memory.add_message(role="user", content=message)
 
         if stream:
             # Handle streaming response
             response = ""
             for chunk in self._stream_response(message, markdown=markdown, **kwargs):
-                print(chunk)
+                print(chunk, end="", flush=True)
                 response += chunk
+            # Store agent response
+            if response:
+                self.memory.add_message(role="assistant", content=response)
+            print()  # New line after streaming
             return response
         else:
             # Generate and return the response
             response = self._generate_response(message, markdown=markdown, team=team, **kwargs)
             print(response)  # Print the response to the console
+            # Store agent response
+            if response:
+                self.memory.add_message(role="assistant", content=response)
             return response
 
 
@@ -294,12 +318,10 @@ class Agent(BaseModel):
         # 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:
             tool_calls = self._analyze_query_and_select_tools(message)
@@ -347,13 +369,17 @@ class Agent(BaseModel):
             try:
                 # Prepare the context for the LLM
                 context = {
+                    "conversation_history": self.memory.get_context(self.llm_instance),
                     "tool_outputs": tool_outputs,
                     "rag_context": self.rag.retrieve(message) if self.rag else None,
-                    "knowledge_base_context": self._find_all_relevant_keys(message, self._flatten_data(self.knowledge_base)) if self.knowledge_base else None,
+                    "knowledge_base": self._get_knowledge_context(message) if self.knowledge_base else None,
                 }
-
+                # 3. Build a memory-aware prompt.
+                prompt = self._build_memory_prompt(message, context)
+                # To (convert MemoryEntry objects to dicts and remove metadata):
+                memory_entries = [{"role": e.role, "content": e.content} for e in self.memory.storage.retrieve()]
                 # Generate a response using the LLM
-                llm_response = self.llm_instance.generate(prompt=message, context=context, **kwargs)
+                llm_response = self.llm_instance.generate(prompt=prompt, context=context, memory=memory_entries, **kwargs)
                 responses.append(f"**Analysis:**\n\n{llm_response}")
             except Exception as e:
                 logger.error(f"Failed to generate LLM response: {e}")
@@ -363,25 +389,30 @@ class Agent(BaseModel):
             # Retrieve relevant context using RAG
             rag_context = self.rag.retrieve(message) if self.rag else None
             # Retrieve relevant context from the knowledge base (API result)
-            knowledge_base_context = None
-            if self.knowledge_base:
-                # Flatten the knowledge base
-                flattened_data = self._flatten_data(self.knowledge_base)
-                # Find all relevant key-value pairs in the knowledge base
-                relevant_values = self._find_all_relevant_keys(message, flattened_data)
-                if relevant_values:
-                    knowledge_base_context = ", ".join(relevant_values)
+            # knowledge_base_context = None
+            # if self.knowledge_base:
+            #     # Flatten the knowledge base
+            #     flattened_data = self._flatten_data(self.knowledge_base)
+            #     # Find all relevant key-value pairs in the knowledge base
+            #     relevant_values = self._find_all_relevant_keys(message, flattened_data)
+            #     if relevant_values:
+            #         knowledge_base_context = ", ".join(relevant_values)
 
             # Combine both contexts (RAG and knowledge base)
             context = {
+                "conversation_history": self.memory.get_context(self.llm_instance),
                 "rag_context": rag_context,
-                "knowledge_base_context": knowledge_base_context,
+                "knowledge_base": self._get_knowledge_context(message),
             }
             # Prepare the prompt with instructions, description, and context
-            prompt = self._build_prompt(message, context)
+            # 3. Build a memory-aware prompt.
+            prompt = self._build_memory_prompt(message, context)
+            # To (convert MemoryEntry objects to dicts and remove metadata):
+            memory_entries = [{"role": e.role, "content": e.content} for e in self.memory.storage.retrieve()]
 
             # Generate the response using the LLM
-            response = self.llm_instance.generate(prompt=prompt, context=context, **kwargs)
+            response = self.llm_instance.generate(prompt=prompt, context=context, memory=memory_entries, **kwargs)
+
 
             # Format the response based on the json_output flag
             if self.json_output:
@@ -394,9 +425,37 @@ class Agent(BaseModel):
             if markdown:
                 return f"**Response:**\n\n{response}"
             return response
-        # Combine all responses into a single string
         return "\n\n".join(responses)
     
+    # Modified prompt construction with memory integration
+    def _build_memory_prompt(self, user_input: str, context: dict) -> str:
+        """Enhanced prompt builder with memory context."""
+        prompt_parts = []
+        
+        if self.description:
+            prompt_parts.append(f"# ROLE\n{self.description}")
+            
+        if self.instructions:
+            prompt_parts.append(f"# INSTRUCTIONS\n" + "\n".join(f"- {i}" for i in self.instructions))
+            
+        if context['conversation_history']:
+            prompt_parts.append(f"# CONVERSATION HISTORY\n{context['conversation_history']}")
+            
+        if context['knowledge_base']:
+            prompt_parts.append(f"# KNOWLEDGE BASE\n{context['knowledge_base']}")
+            
+        prompt_parts.append(f"# USER INPUT\n{user_input}")
+        
+        return "\n\n".join(prompt_parts)
+        
+    def _get_knowledge_context(self, message: str) -> str:
+        """Retrieve and format knowledge base context."""
+        if not self.knowledge_base:
+            return ""
+        
+        flattened = self._flatten_data(self.knowledge_base)
+        relevant = self._find_all_relevant_keys(message, flattened)
+        return "\n".join(f"- {item}" for item in relevant) if relevant else ""
     def _generate_team_response(self, message: str, team: List['Agent'], markdown: bool = False, **kwargs) -> str:
         """Generate a response using a team of assistants."""
         responses = []
@@ -543,17 +602,21 @@ class Agent(BaseModel):
         """Run the agent in a CLI app."""
         from rich.prompt import Prompt
 
+        # Print initial message if provided
         if message:
             self.print_response(message=message, **kwargs)
 
         _exit_on = exit_on or ["exit", "quit", "bye"]
         while True:
-            message = Prompt.ask(f"[bold] {self.emoji} {self.user_name} [/bold]")
-            if message in _exit_on:
+            try:
+                message = Prompt.ask(f"[bold] {self.emoji} {self.user_name} [/bold]")
+                if message in _exit_on:
+                    break
+                self.print_response(message=message, **kwargs)
+            except KeyboardInterrupt:
+                print("\n\nSession ended. Goodbye!")
                 break
 
-            self.print_response(message=message, **kwargs)
-
     def _generate_api(self):
         """Generate an API for the agent if api=True."""
         from .api.api_generator import APIGenerator

semantio/memory.py

@@ -1,11 +1,54 @@
-from typing import List, Dict
-
+from .models import MemoryEntry
+from .storage import BaseMemoryStorage, InMemoryStorage, FileStorage
+from typing import List, Dict, Optional
+from .llm.base_llm import BaseLLM
 class Memory:
-    def __init__(self):
-        self.history = []
+    def __init__(
+        self,
+        storage: BaseMemoryStorage = InMemoryStorage(),
+        max_context_length: int = 4000,
+        summarization_threshold: int = 3000
+    ):
+        self.storage = storage
+        self.max_context_length = max_context_length
+        self.summarization_threshold = summarization_threshold
+        self._current_context = ""
+
+    def add_message(self, role: str, content: str, metadata: Optional[Dict] = None):
+        entry = MemoryEntry(
+            role=role,
+            content=content,
+            metadata=metadata or {}
+        )
+        self.storage.store(entry)
+        self._manage_context()
+
+    def get_context(self, llm: Optional[BaseLLM] = None) -> str:
+        if len(self._current_context) < self.summarization_threshold:
+            return self._current_context
+        
+        # Automatic summarization when context grows too large
+        if llm:
+            return self.summarize(llm)
+        return self._current_context[:self.max_context_length]
+    def _manage_context(self):
+        # Include roles in the conversation history
+        full_history = "\n".join([f"{e.role}: {e.content}" for e in self.storage.retrieve()])
+        if len(full_history) > self.max_context_length:
+            self._current_context = full_history[-self.max_context_length:]
+        else:
+            self._current_context = full_history
 
-    def add_message(self, role: str, content: str):
-        self.history.append({"role": role, "content": content})
+    def summarize(self, llm: BaseLLM) -> str:
+        # Include roles in the history for summarization
+        history = "\n".join([f"{e.role}: {e.content}" for e in self.storage.retrieve()])
+        prompt = f"""
+        Summarize this conversation history maintaining key details and references:
+        {history[-self.summarization_threshold:]}
+        """
+        self._current_context = llm.generate(prompt)
+        return self._current_context
 
-    def get_history(self) -> List[Dict]:
-        return self.history
+    def clear(self):
+        self.storage = InMemoryStorage()
+        self._current_context = ""

semantio/models.py

@@ -0,0 +1,9 @@
+from pydantic import BaseModel, Field
+from datetime import datetime
+from typing import Dict
+
+class MemoryEntry(BaseModel):
+    role: str  # "user" or "assistant"
+    content: str
+    timestamp: datetime = Field(default_factory=datetime.now)
+    metadata: Dict = Field(default_factory=dict)

semantio/storage/__init__.py

@@ -0,0 +1,5 @@
+from .base_storage import BaseMemoryStorage
+from .in_memory_storage import InMemoryStorage
+from .local_storage import FileStorage
+
+__all__ = ['BaseMemoryStorage', 'InMemoryStorage', 'FileStorage']

semantio/storage/base_storage.py

@@ -0,0 +1,12 @@
+from abc import ABC, abstractmethod
+from typing import List, Optional
+from ..models import MemoryEntry
+
+class BaseMemoryStorage(ABC):
+    @abstractmethod
+    def store(self, entry: MemoryEntry):
+        pass
+    
+    @abstractmethod
+    def retrieve(self, query: Optional[str] = None, limit: int = 20) -> List[MemoryEntry]:
+        pass

semantio/storage/in_memory_storage.py

@@ -0,0 +1,14 @@
+# hashai/storage/in_memory_storage.py
+from typing import List, Optional
+from ..models import MemoryEntry
+from .base_storage import BaseMemoryStorage
+
+class InMemoryStorage(BaseMemoryStorage):
+    def __init__(self):
+        self.history: List[MemoryEntry] = []
+    
+    def store(self, entry: MemoryEntry):
+        self.history.append(entry)
+    
+    def retrieve(self, query: Optional[str] = None, limit: int = 10) -> List[MemoryEntry]:
+        return self.history[-limit:]

semantio/storage/local_storage.py

@@ -0,0 +1,29 @@
+import json
+from typing import List, Optional
+from ..models import MemoryEntry
+from .base_storage import BaseMemoryStorage
+
+class FileStorage(BaseMemoryStorage):
+    def __init__(self, file_path: str = "memory.json"):
+        self.file_path = file_path
+        self.history = self._load_from_file()
+
+    def _load_from_file(self) -> List[MemoryEntry]:
+        try:
+            with open(self.file_path, "r") as f:
+                data = json.load(f)
+                return [MemoryEntry(**entry) for entry in data]
+        except (FileNotFoundError, json.JSONDecodeError):
+            return []
+
+    def _save_to_file(self):
+        with open(self.file_path, "w") as f:
+            data = [entry.dict() for entry in self.history]
+            json.dump(data, f, default=str)
+
+    def store(self, entry: MemoryEntry):
+        self.history.append(entry)
+        self._save_to_file()
+
+    def retrieve(self, query: Optional[str] = None, limit: int = 20) -> List[MemoryEntry]:
+        return self.history[-limit:]

semantio/tools/web_browser.py

@@ -1,8 +1,10 @@
 # web_browser.py
-from typing import Dict, Any, List, Optional
+from typing import Dict, Any, List, Optional, Callable
 from pydantic import Field, BaseModel
 from selenium import webdriver
 from selenium.webdriver.common.by import By
+from selenium.webdriver.common.action_chains import ActionChains
+from selenium.webdriver.remote.webelement import WebElement
 from selenium.webdriver.support.ui import WebDriverWait
 from selenium.webdriver.support import expected_conditions as EC
 from selenium.webdriver.chrome.options import Options
@@ -13,6 +15,8 @@ import json
 import time
 import re
 import logging
+import os
+import difflib
 from .base_tool import BaseTool
 
 logger = logging.getLogger(__name__)
@@ -26,99 +30,140 @@ class BrowserPlan(BaseModel):
 class WebBrowserTool(BaseTool):
     name: str = Field("WebBrowser", description="Name of the tool")
     description: str = Field(
-        "Universal web automation tool for dynamic website interactions",
+        "Highly advanced universal web automation tool with advanced element identification, AJAX waiting, modal dismissal, multi-tab support, and custom JS injection.",
         description="Tool description"
     )
     
+    default_timeout: int = 15  # Default wait timeout in seconds
+    max_retries: int = 3       # Increased maximum retries for any task
+
     def execute(self, input: Dict[str, Any]) -> Dict[str, Any]:
-        """Execute dynamic web automation workflow"""
+        """Execute an advanced dynamic web automation workflow."""
         driver = None
+        overall_start = time.time()
         try:
-            driver = self._init_browser(input.get("headless", False))
+            headless = input.get("headless", False)
+            self.default_timeout = int(input.get("timeout", self.default_timeout))
+            self.max_retries = int(input.get("max_retries", self.max_retries))
+            driver = self._init_browser(headless)
             results = []
             current_url = ""
 
-            # Generate initial plan
-            plan = self._generate_plan(input['query'], current_url)
+            plan = self._generate_plan(input.get('query', ''), current_url)
+            if not plan.tasks:
+                raise ValueError("No valid tasks in the generated plan.")
+
+            # Dynamic mapping: action name to handler function.
+            action_map: Dict[str, Callable[[webdriver.Chrome, Dict[str, Any]], Dict[str, Any]]] = {
+                "navigate": lambda d, task: self._handle_navigation(d, task.get("value", "")),
+                "click": lambda d, task: self._handle_click(d, task.get("selector", "")),
+                "type": lambda d, task: self._handle_typing(d, task.get("selector", ""), task.get("value", ""), task),
+                "wait": lambda d, task: self._handle_wait(task.get("value", "")),
+                "wait_for_ajax": lambda d, task: self._handle_wait_for_ajax(d, task.get("value", "30")),
+                "scroll": lambda d, task: self._handle_scroll(d, task.get("selector", "")),
+                "hover": lambda d, task: self._handle_hover(d, task.get("selector", "")),
+                "screenshot": lambda d, task: self._handle_screenshot(d, task.get("value", "screenshot.png")),
+                "switch_tab": lambda d, task: self._handle_switch_tab(d, task.get("value", "0")),
+                "execute_script": lambda d, task: self._handle_execute_script(d, task.get("value", "")),
+                "drag_and_drop": lambda d, task: self._handle_drag_and_drop(d, task.get("selector", ""), task.get("value", "")),
+            }
             
             for task in plan.tasks:
-                result = self._execute_safe_task(driver, task)
+                # Before each action, dismiss modals/overlays.
+                self._dismiss_unwanted_modals(driver)
+                action = task.get("action", "").lower()
+                logger.info(f"Executing task: {task.get('description', action)}")
+                start_time = time.time()
+                handler = action_map.get(action)
+                if not handler:
+                    results.append({
+                        "action": action,
+                        "success": False,
+                        "message": f"Unsupported action: {action}"
+                    })
+                    continue
+
+                result = self._execute_with_retries(driver, task, handler)
+                elapsed = time.time() - start_time
+                result["elapsed"] = elapsed
+                logger.info(f"Action '{action}' completed in {elapsed:.2f} seconds.")
                 results.append(result)
-                
-                if not result['success']:
+
+                if not result.get('success', False):
+                    logger.error(f"Task failed: {result.get('message')}")
+                    self._capture_failure_screenshot(driver, action)
                     break
-                    
-                # Update context for next tasks
+
                 current_url = driver.current_url
 
-            return {"status": "success", "results": results}
+            overall_elapsed = time.time() - overall_start
+            logger.info(f"Total execution time: {overall_elapsed:.2f} seconds.")
+            return {"status": "success", "results": results, "total_time": overall_elapsed}
             
         except Exception as e:
+            logger.exception("Execution error:")
             return {"status": "error", "message": str(e)}
         finally:
             if driver:
                 driver.quit()
 
     def _init_browser(self, headless: bool) -> webdriver.Chrome:
-        """Initialize browser with advanced options"""
+        """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
         )
 
     def _generate_plan(self, query: str, current_url: str) -> BrowserPlan:
-        """Generate adaptive execution plan using LLM"""
+        """Generate an adaptive execution plan using an LLM or other dynamic planner."""
         prompt = f"""Generate browser automation plan for: {query}
-        
-        Current URL: {current_url or 'No page loaded yet'}
-        
-        Required JSON format:
+
+Current URL: {current_url or 'No page loaded yet'}
+
+Required JSON format:
+{{
+    "tasks": [
         {{
-            "tasks": [
-                {{
-                    "action": "navigate|click|type|wait|scroll",
-                    "selector": "CSS selector (optional)",
-                    "value": "input text/URL/seconds",
-                    "description": "action purpose"
-                }}
-            ]
+            "action": "navigate|click|type|wait|wait_for_ajax|scroll|hover|screenshot|switch_tab|execute_script|drag_and_drop",
+            "selector": "CSS selector (optional)",
+            "value": "input text/URL/seconds/filename/target-selector",
+            "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
-        """
-        
+    ]
+}}
+
+Guidelines:
+1. Prefer IDs in selectors (#element-id) and semantic attributes.
+2. Include wait steps after navigation and wait for AJAX where applicable.
+3. Dismiss any modals/pop-ups that are not part of the task.
+4. For drag_and_drop, use source selector in 'selector' and target selector in 'value'.
+5. For execute_script, 'value' should contain valid JavaScript.
+6. For switch_tab, 'value' should be an index or keyword 'new'.
+"""
         response = self.llm.generate(prompt=prompt)
         return self._parse_plan(response)
 
     def _parse_plan(self, response: str) -> BrowserPlan:
-        """Robust JSON parsing with multiple fallback strategies"""
+        """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
+                json_str_match = re.search(r'\{.*\}', response, re.DOTALL)
+                if not json_str_match:
+                    raise ValueError("No JSON object found in the response.")
+                plan_data = json.loads(json_str_match.group())
             validated_tasks = []
             for task in plan_data.get("tasks", []):
                 if not all(key in task for key in ["action", "description"]):
+                    logger.warning(f"Skipping task due to missing keys: {task}")
                     continue
                 validated_tasks.append({
                     "action": task["action"],
@@ -126,146 +171,269 @@ class WebBrowserTool(BaseTool):
                     "value": task.get("value", ""),
                     "description": task["description"]
                 })
-            
             return BrowserPlan(tasks=validated_tasks)
-            
-        except (json.JSONDecodeError, AttributeError) as e:
+        except (json.JSONDecodeError, AttributeError, ValueError) as e:
             logger.error(f"Plan parsing failed: {e}")
             return BrowserPlan(tasks=[])
 
-    def _execute_safe_task(self, driver, task: Dict) -> Dict[str, Any]:
-        """Execute task with comprehensive error handling"""
+    def _execute_with_retries(self, driver: webdriver.Chrome, task: Dict[str, Any],
+                                handler: Callable[[webdriver.Chrome, Dict[str, Any]], Dict[str, Any]]) -> Dict[str, Any]:
+        """Execute a task with retry logic and exponential backoff."""
+        attempts = 0
+        result = {}
+        while attempts < self.max_retries:
+            result = self._execute_safe_task(driver, task, handler)
+            if result.get("success", False):
+                return result
+            attempts += 1
+            logger.info(f"Retrying task '{task.get('action')}' (attempt {attempts + 1}/{self.max_retries})")
+            time.sleep(1 * attempts)
+        return result
+
+    def _execute_safe_task(self, driver: webdriver.Chrome, task: Dict[str, Any],
+                             handler: Callable[[webdriver.Chrome, Dict[str, Any]], Dict[str, Any]]) -> Dict[str, Any]:
+        """Execute a 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}"
-            }
-            
+            return handler(driver, task)
         except Exception as e:
-            return {
-                "action": action,
-                "success": False,
-                "message": f"Critical error: {str(e)}"
-            }
+            action = task.get("action", "unknown")
+            logger.exception(f"Error executing task '{action}':")
+            return {"action": action, "success": False, "message": f"Critical error: {str(e)}"}
 
-    def _handle_navigation(self, driver, url: str) -> Dict[str, Any]:
-        """Smart navigation handler"""
+    def _dismiss_unwanted_modals(self, driver: webdriver.Chrome):
+        """
+        Dismiss or remove unwanted modals, overlays, or pop-ups.
+        First attempts to click a close button; if not available, removes the element via JS.
+        """
+        try:
+            modal_selectors = [".modal", ".popup", '[role="dialog"]', ".overlay", ".lightbox"]
+            for selector in modal_selectors:
+                elements = driver.find_elements(By.CSS_SELECTOR, selector)
+                for modal in elements:
+                    if modal.is_displayed():
+                        close_selectors = [".close", ".btn-close", "[aria-label='Close']", "[data-dismiss='modal']"]
+                        dismissed = False
+                        for close_sel in close_selectors:
+                            try:
+                                close_button = modal.find_element(By.CSS_SELECTOR, close_sel)
+                                if close_button.is_displayed():
+                                    close_button.click()
+                                    dismissed = True
+                                    logger.info(f"Dismissed modal using selector {close_sel}")
+                                    time.sleep(1)
+                                    break
+                            except Exception:
+                                continue
+                        if not dismissed:
+                            # Remove overlay by setting display to none
+                            driver.execute_script("arguments[0].remove();", modal)
+                            logger.info(f"Removed overlay/modal with selector {selector}")
+        except Exception as e:
+            logger.debug(f"Modal dismissal error: {e}")
+
+    def _advanced_find_element(self, driver: webdriver.Chrome, keyword: str) -> Optional[WebElement]:
+        """
+        Advanced fallback for finding an element.
+        Searches across multiple attributes and inner text using fuzzy matching.
+        """
+        candidates = driver.find_elements(By.CSS_SELECTOR, "input, textarea, button, a, div")
+        best_match = None
+        best_ratio = 0.0
+        for candidate in candidates:
+            combined_text = " ".join([
+                candidate.get_attribute("id") or "",
+                candidate.get_attribute("name") or "",
+                candidate.get_attribute("placeholder") or "",
+                candidate.get_attribute("aria-label") or "",
+                candidate.text or "",
+            ])
+            ratio = difflib.SequenceMatcher(None, combined_text.lower(), keyword.lower()).ratio()
+            if ratio > best_ratio:
+                best_ratio = ratio
+                best_match = candidate
+        if best_ratio > 0.5:
+            logger.info(f"Advanced fallback detected element with similarity {best_ratio:.2f} for keyword '{keyword}'")
+            return best_match
+        return None
+
+    def _handle_navigation(self, driver: webdriver.Chrome, url: str) -> Dict[str, Any]:
+        """Handle navigation with URL correction."""
         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}"
-            }
+            WebDriverWait(driver, self.default_timeout).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)}"
-            }
+            logger.error(f"Navigation to {url} failed: {e}")
+            return {"action": "navigate", "success": False, "message": f"Navigation failed: {str(e)}"}
 
-    def _handle_click(self, driver, selector: str) -> Dict[str, Any]:
-        """Dynamic click handler"""
+    def _handle_click(self, driver: webdriver.Chrome, selector: str) -> Dict[str, Any]:
+        """Handle click actions with fallback using JS if needed."""
         try:
-            element = WebDriverWait(driver, 15).until(
+            element = WebDriverWait(driver, self.default_timeout).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}"
-            }
+            driver.execute_script("arguments[0].scrollIntoView({behavior: 'smooth', block: 'center'});", element)
+            try:
+                element.click()
+            except Exception:
+                driver.execute_script("arguments[0].click();", element)
+            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)}"
-            }
+            logger.error(f"Click action failed on selector {selector}: {e}")
+            return {"action": "click", "success": False, "message": f"Click failed: {str(e)}"}
 
-    def _handle_typing(self, driver, selector: str, text: str) -> Dict[str, Any]:
-        """Universal typing handler"""
+    def _handle_typing(self, driver: webdriver.Chrome, selector: str, text: str, task: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Handle typing into an element.
+        If the primary selector fails, attempt advanced fallback detection.
+        """
         try:
-            element = WebDriverWait(driver, 15).until(
+            element = WebDriverWait(driver, self.default_timeout).until(
                 EC.presence_of_element_located((By.CSS_SELECTOR, selector))
             )
+        except Exception as e:
+            # If the task seems to involve search or similar text, use advanced fallback.
+            if "search" in task.get("description", "").lower() or "search" in selector.lower():
+                logger.info("Primary selector failed; using advanced fallback for element detection.")
+                element = self._advanced_find_element(driver, "search")
+                if not element:
+                    return {"action": "type", "success": False, "message": f"Typing failed: No search-like element found; error: {str(e)}"}
+            else:
+                return {"action": "type", "success": False, "message": f"Typing failed: {str(e)}"}
+        try:
             element.clear()
             element.send_keys(text)
-            return {
-                "action": "type",
-                "success": True,
-                "message": f"Typed '{text}' into {selector}"
-            }
+            return {"action": "type", "success": True, "message": f"Typed '{text}' into element."}
         except Exception as e:
-            return {
-                "action": "type",
-                "success": False,
-                "message": f"Typing failed: {str(e)}"
-            }
+            logger.error(f"Typing action failed: {e}")
+            return {"action": "type", "success": False, "message": f"Typing failed: {str(e)}"}
 
     def _handle_wait(self, seconds: str) -> Dict[str, Any]:
-        """Configurable wait handler"""
+        """Handle a simple wait."""
         try:
             wait_time = float(seconds)
+            logger.info(f"Waiting for {wait_time} 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"
-            }
+            return {"action": "wait", "success": True, "message": f"Waited {wait_time} seconds"}
+        except ValueError as e:
+            logger.error(f"Invalid wait time provided: {seconds}")
+            return {"action": "wait", "success": False, "message": "Invalid wait time"}
+
+    def _handle_wait_for_ajax(self, driver: webdriver.Chrome, seconds: str) -> Dict[str, Any]:
+        """
+        Wait until AJAX/network activity has subsided.
+        This implementation first checks for jQuery, then falls back to a generic check.
+        """
+        try:
+            timeout = int(seconds)
+            logger.info(f"Waiting for AJAX/network activity for up to {timeout} seconds.")
+            end_time = time.time() + timeout
+            while time.time() < end_time:
+                ajax_complete = driver.execute_script("""
+                    return (window.jQuery ? jQuery.active === 0 : true) &&
+                           (typeof window.fetch === 'function' ? true : true);
+                """)
+                if ajax_complete:
+                    break
+                time.sleep(0.5)
+            return {"action": "wait_for_ajax", "success": True, "message": "AJAX/network activity subsided."}
+        except Exception as e:
+            logger.error(f"Wait for AJAX failed: {e}")
+            return {"action": "wait_for_ajax", "success": False, "message": f"Wait for AJAX failed: {str(e)}"}
 
-    def _handle_scroll(self, driver, selector: str) -> Dict[str, Any]:
-        """Smart scroll handler"""
+    def _handle_scroll(self, driver: webdriver.Chrome, selector: str) -> Dict[str, Any]:
+        """Handle scrolling to a specific element or page bottom."""
         try:
             if selector:
-                element = WebDriverWait(driver, 15).until(
+                element = WebDriverWait(driver, self.default_timeout).until(
                     EC.presence_of_element_located((By.CSS_SELECTOR, selector))
                 )
-                driver.execute_script("arguments[0].scrollIntoView({behavior: 'smooth'});", element)
+                driver.execute_script("arguments[0].scrollIntoView({behavior: 'smooth', block: 'center'});", element)
+                scroll_target = selector
             else:
                 driver.execute_script("window.scrollTo(0, document.body.scrollHeight);")
-                
-            return {
-                "action": "scroll",
-                "success": True,
-                "message": f"Scrolled to {selector or 'page bottom'}"
-            }
+                scroll_target = "page bottom"
+            return {"action": "scroll", "success": True, "message": f"Scrolled to {scroll_target}"}
+        except Exception as e:
+            logger.error(f"Scroll action failed on selector {selector}: {e}")
+            return {"action": "scroll", "success": False, "message": f"Scroll failed: {str(e)}"}
+
+    def _handle_hover(self, driver: webdriver.Chrome, selector: str) -> Dict[str, Any]:
+        """Handle mouse hover action."""
+        try:
+            element = WebDriverWait(driver, self.default_timeout).until(
+                EC.visibility_of_element_located((By.CSS_SELECTOR, selector))
+            )
+            ActionChains(driver).move_to_element(element).perform()
+            return {"action": "hover", "success": True, "message": f"Hovered over {selector}"}
+        except Exception as e:
+            logger.error(f"Hover action failed on selector {selector}: {e}")
+            return {"action": "hover", "success": False, "message": f"Hover failed: {str(e)}"}
+
+    def _handle_screenshot(self, driver: webdriver.Chrome, filename: str) -> Dict[str, Any]:
+        """Capture a screenshot of the current browser state."""
+        try:
+            driver.save_screenshot(filename)
+            return {"action": "screenshot", "success": True, "message": f"Screenshot saved as {filename}"}
+        except Exception as e:
+            logger.error(f"Screenshot capture failed: {e}")
+            return {"action": "screenshot", "success": False, "message": f"Screenshot failed: {str(e)}"}
+
+    def _handle_switch_tab(self, driver: webdriver.Chrome, value: str) -> Dict[str, Any]:
+        """
+        Switch between tabs. 'value' can be an index or the keyword 'new'.
+        """
+        try:
+            handles = driver.window_handles
+            if value.lower() == "new":
+                target_handle = handles[-1]
+            else:
+                idx = int(value)
+                if idx < len(handles):
+                    target_handle = handles[idx]
+                else:
+                    return {"action": "switch_tab", "success": False, "message": f"Tab index {value} out of range"}
+            driver.switch_to.window(target_handle)
+            return {"action": "switch_tab", "success": True, "message": f"Switched to tab {value}"}
+        except Exception as e:
+            logger.error(f"Switch tab failed: {e}")
+            return {"action": "switch_tab", "success": False, "message": f"Switch tab failed: {str(e)}"}
+
+    def _handle_execute_script(self, driver: webdriver.Chrome, script: str) -> Dict[str, Any]:
+        """
+        Execute arbitrary JavaScript code.
+        """
+        try:
+            result = driver.execute_script(script)
+            return {"action": "execute_script", "success": True, "message": "Script executed successfully", "result": result}
+        except Exception as e:
+            logger.error(f"Execute script failed: {e}")
+            return {"action": "execute_script", "success": False, "message": f"Script execution failed: {str(e)}"}
+
+    def _handle_drag_and_drop(self, driver: webdriver.Chrome, source_selector: str, target_selector: str) -> Dict[str, Any]:
+        """
+        Simulate a drag-and-drop operation.
+        """
+        try:
+            source = WebDriverWait(driver, self.default_timeout).until(
+                EC.presence_of_element_located((By.CSS_SELECTOR, source_selector))
+            )
+            target = WebDriverWait(driver, self.default_timeout).until(
+                EC.presence_of_element_located((By.CSS_SELECTOR, target_selector))
+            )
+            ActionChains(driver).drag_and_drop(source, target).perform()
+            return {"action": "drag_and_drop", "success": True, "message": f"Dragged element from {source_selector} to {target_selector}"}
+        except Exception as e:
+            logger.error(f"Drag and drop failed from {source_selector} to {target_selector}: {e}")
+            return {"action": "drag_and_drop", "success": False, "message": f"Drag and drop failed: {str(e)}"}
+
+    def _capture_failure_screenshot(self, driver: webdriver.Chrome, action: str):
+        """Capture a screenshot for debugging when an error occurs."""
+        filename = f"failure_{action}_{int(time.time())}.png"
+        try:
+            driver.save_screenshot(filename)
+            logger.info(f"Failure screenshot captured: {filename}")
         except Exception as e:
-            return {
-                "action": "scroll",
-                "success": False,
-                "message": f"Scroll failed: {str(e)}"
-            }
+            logger.error(f"Failed to capture screenshot: {e}")

{semantio-0.0.4.dist-info → semantio-0.0.6.dist-info}/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2025 Syenah
+Copyright (c) 2025 Syenah (Semantio)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: semantio
-Version: 0.0.4
+Version: 0.0.6
 Summary: A powerful SDK for building AI agents
 Home-page: https://github.com/Syenah/semantio
 Author: Rakesh

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

@@ -1,6 +1,7 @@
-semantio/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-semantio/agent.py,sha256=hKytSI5LqNnxqVvwI2hOINqPgrdhUXY9MS_90_crZPs,28584
-semantio/memory.py,sha256=eNAwyAokppHzMcIyFgOw2hT2wnLQBd9GL4T5eallNV4,281
+semantio/__init__.py,sha256=RIeSI07dGyWBK-STKIk4IeB4bkn_3-QEKQklzSvR7hQ,82
+semantio/agent.py,sha256=uPFz1WP2eb-z-tryQOX8necS8_tv4Il6qxNmZux9hNk,31709
+semantio/memory.py,sha256=en9n3UySnj4rA0x3uR1sEdEzA7EkboQNbEHQ5KuEehw,2115
+semantio/models.py,sha256=7hmP-F_aSU8WvsG3NGeC_hep-rUbiSbjUFMDVbpKxQE,289
 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
@@ -19,24 +20,26 @@ semantio/llm/gemini.py,sha256=er3zv1jOvWQBGbPuv4fS4pR_c_abHyhroe-rkXupOO4,1959
 semantio/llm/groq.py,sha256=1AH30paKzDIQjBjWPQPN44QwFHsIOVwI-a587-cDIVc,4285
 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
+semantio/storage/__init__.py,sha256=bGSJjA1qk6DUDrBijmWcQk3Y1a2K00MPoKI5KH43Ang,196
+semantio/storage/base_storage.py,sha256=R9tQfidVZlCN6CyvnhB-Tc2lIZ7yQsyX4cbMoud64XM,336
 semantio/storage/cloud_storage.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-semantio/storage/local_storage.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+semantio/storage/in_memory_storage.py,sha256=aZT8rRHF6Kz_udaqf0rux7XRFKf9Hr3d4c3Ylry7J14,474
+semantio/storage/local_storage.py,sha256=Z8jCPo2MwZ8tuhQywWkHyxTrdSyYtzAPSNd46DTCth8,1007
 semantio/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 semantio/tools/base_tool.py,sha256=xBNSa_8a8WmA4BGRLG2dE7wj9GnBcZo7-P2SyD86GvY,571
 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=wqr5pj2GybkK9IHDb8C1BipS8ujV2l36WlwA8ZbKd88,9711
+semantio/tools/web_browser.py,sha256=ZjE-nrRtUEUoh6LNutMjdn9_bTlnVGU2PM2w6orjUWA,22172
 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.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,,
+semantio-0.0.6.dist-info/LICENSE,sha256=mziLlfb9hZ8HKxm9V6BiHpmgJvmcDvswu1QBlDB-6vU,1074
+semantio-0.0.6.dist-info/METADATA,sha256=SeDpiywG59La7HcAQxZHxk8uXLFoyEv3otMFYkJl5W4,6913
+semantio-0.0.6.dist-info/WHEEL,sha256=ewwEueio1C2XeHTvT17n8dZUJgOvyCWCt0WVNLClP9o,92
+semantio-0.0.6.dist-info/entry_points.txt,sha256=zbPgevSLwcLpdRHqI_atE8EOt8lK2vRF1AoDflDTo18,53
+semantio-0.0.6.dist-info/top_level.txt,sha256=Yte_6mb-bh-I_lQwMjk1GijZkxPoX4Zmp3kBftC1ZlA,9
+semantio-0.0.6.dist-info/RECORD,,