autobyteus 1.1.9__py3-none-any.whl → 1.2.1__py3-none-any.whl

examples/run_agentic_software_engineer.py

@@ -0,0 +1,239 @@
+# file: autobyteus/examples/run_agentic_software_engineer.py
+import asyncio
+import logging
+import argparse
+from pathlib import Path
+import sys
+import os
+
+# --- Boilerplate to make the script runnable from the project root ---
+SCRIPT_DIR = Path(__file__).resolve().parent
+PACKAGE_ROOT = SCRIPT_DIR.parent
+if str(PACKAGE_ROOT) not in sys.path:
+    sys.path.insert(0, str(PACKAGE_ROOT))
+
+# Load environment variables from .env file in the project root
+try:
+    from dotenv import load_dotenv
+    env_file_path = PACKAGE_ROOT / ".env"
+    if env_file_path.exists():
+        load_dotenv(env_file_path)
+        print(f"Loaded environment variables from: {env_file_path}")
+    else:
+        print(f"Info: No .env file found at: {env_file_path}. Relying on exported environment variables.")
+except ImportError:
+    print("Warning: python-dotenv not installed. Cannot load .env file.")
+
+# --- Imports for the Agentic Software Engineer Example ---
+try:
+    # Tool related imports
+    from autobyteus.tools.registry import default_tool_registry
+    from autobyteus.tools.tool_origin import ToolOrigin
+    # Import local tools to ensure they are registered
+    import autobyteus.tools.local_tools
+
+    # Workspace imports
+    from autobyteus.agent.workspace.local_workspace import LocalWorkspace
+    from autobyteus.agent.workspace.workspace_config import WorkspaceConfig
+
+    # For Agent creation
+    from autobyteus.agent.context.agent_config import AgentConfig
+    from autobyteus.llm.models import LLMModel
+    from autobyteus.llm.llm_factory import default_llm_factory, LLMFactory
+    from autobyteus.agent.factory.agent_factory import AgentFactory
+    from autobyteus.cli import agent_cli
+except ImportError as e:
+    print(f"Error importing autobyteus components: {e}", file=sys.stderr)
+    print("Please ensure that the autobyteus library is installed and accessible.", file=sys.stderr)
+    sys.exit(1)
+
+# --- Logging Setup ---
+logger = logging.getLogger("agentic_swe_example")
+interactive_logger = logging.getLogger("autobyteus.cli.interactive")
+
+def setup_logging(args: argparse.Namespace):
+    """
+    Configures logging for the interactive session.
+    """
+    loggers_to_clear = [
+        logging.getLogger(),
+        logging.getLogger("autobyteus"),
+        logging.getLogger("autobyteus.cli"),
+        interactive_logger,
+    ]
+    for l in loggers_to_clear:
+        if l.hasHandlers():
+            for handler in l.handlers[:]:
+                l.removeHandler(handler)
+                if hasattr(handler, 'close'): handler.close()
+
+    script_log_level = logging.DEBUG if args.debug else logging.INFO
+
+    # 1. Handler for unformatted interactive output
+    interactive_handler = logging.StreamHandler(sys.stdout)
+    interactive_logger.addHandler(interactive_handler)
+    interactive_logger.setLevel(logging.INFO)
+    interactive_logger.propagate = False
+
+    # 2. Handler for formatted console logs
+    console_formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(name)s - %(message)s')
+    
+    class FormattedConsoleFilter(logging.Filter):
+        def filter(self, record):
+            if record.name.startswith("agentic_swe_example") or record.name.startswith("autobyteus.cli"):
+                return True
+            if record.levelno >= logging.CRITICAL:
+                return True
+            return False
+
+    formatted_console_handler = logging.StreamHandler(sys.stdout)
+    formatted_console_handler.setFormatter(console_formatter)
+    formatted_console_handler.addFilter(FormattedConsoleFilter())
+    
+    root_logger = logging.getLogger()
+    root_logger.addHandler(formatted_console_handler)
+    root_logger.setLevel(script_log_level) 
+    
+    # 3. Handler for the main agent log file
+    log_file_path = Path(args.agent_log_file).resolve()
+    log_file_path.parent.mkdir(parents=True, exist_ok=True)
+    agent_file_handler = logging.FileHandler(log_file_path, mode='w')  
+    agent_file_formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(name)s:%(lineno)d - %(message)s')
+    agent_file_handler.setFormatter(agent_file_formatter)
+    file_log_level = logging.DEBUG if args.debug else logging.INFO
+
+    autobyteus_logger = logging.getLogger("autobyteus")
+    autobyteus_logger.addHandler(agent_file_handler)
+    autobyteus_logger.setLevel(file_log_level)
+    autobyteus_logger.propagate = True
+
+    # 4. Configure `autobyteus.cli` package logging
+    cli_logger = logging.getLogger("autobyteus.cli")
+    cli_logger.setLevel(script_log_level)
+    cli_logger.propagate = True
+    
+    logger.info(f"Core library logs (excluding CLI) redirected to: {log_file_path} (level: {logging.getLevelName(file_log_level)})")
+
+# --- Environment Variable Checks ---
+def check_required_env_vars():
+    """Checks for environment variables required by this example. None are strictly required."""
+    logger.info("No specific environment variables are required, but ensure your chosen LLM provider's API key is set (e.g., GOOGLE_API_KEY).")
+    return {}
+
+async def main(args: argparse.Namespace):
+    """Main function to configure and run the Agentic Software Engineer."""
+    logger.info("--- Starting Agentic Software Engineer Example ---")
+    check_required_env_vars()
+
+    try:
+        # 1. Create a workspace for the agent.
+        workspace_path = Path(args.workspace_path).resolve()
+        workspace_path.mkdir(parents=True, exist_ok=True)
+        logger.info(f"Agent workspace initialized at: {workspace_path}")
+        workspace_config = WorkspaceConfig(params={"root_path": str(workspace_path)})
+        workspace = LocalWorkspace(config=workspace_config)
+
+        # 2. Get all available local tools.
+        tool_registry = default_tool_registry
+        local_tool_defs = tool_registry.get_tools_by_origin(ToolOrigin.LOCAL)
+        local_tool_names = [tool_def.name for tool_def in local_tool_defs]
+        
+        if not local_tool_names:
+            logger.error("No local tools were found in the registry. Cannot create agent.")
+            return
+
+        logger.info(f"Creating instances for registered local tools: {local_tool_names}")
+        tools_for_agent = [tool_registry.create_tool(name) for name in local_tool_names]
+        
+        # 3. Configure and create the agent.
+        try:
+            _ = LLMModel[args.llm_model]
+        except (KeyError, ValueError):
+            logger.error(f"LLM Model '{args.llm_model}' is not valid or ambiguous.", file=sys.stderr)
+            try:
+                LLMFactory.ensure_initialized()
+                print("\nAvailable LLM Models (use the 'Identifier' with --llm-model):")
+                all_models = sorted(list(LLMModel), key=lambda m: m.model_identifier)
+                if not all_models:
+                    print("  No models found.")
+                for model in all_models:
+                    print(f"  - Display Name: {model.name:<30} Identifier: {model.model_identifier}")
+            except Exception as e:
+                print(f"Additionally, an error occurred while listing models: {e}", file=sys.stderr)
+            sys.exit(1)
+
+        logger.info(f"Creating LLM instance for model: {args.llm_model}")
+        llm_instance = default_llm_factory.create_llm(model_identifier=args.llm_model)
+        
+        # Load system prompt from file
+        prompt_path = SCRIPT_DIR / "prompts" / "agentic_software_engineer.prompt"
+        if not prompt_path.exists():
+            logger.error(f"System prompt file not found at: {prompt_path}")
+            sys.exit(1)
+        with open(prompt_path, "r", encoding="utf-8") as f:
+            system_prompt = f.read()
+        logger.info(f"Loaded system prompt from: {prompt_path}")
+
+        agent_config = AgentConfig(
+            name="AgenticSoftwareDeveloper",
+            role="SoftwareEngineer",
+            description="An AI agent that can reason, plan, and execute software development tasks.",
+            llm_instance=llm_instance,
+            system_prompt=system_prompt,
+            tools=tools_for_agent,
+            workspace=workspace,
+            use_xml_tool_format=True,  # As specified in the prompt
+            auto_execute_tools=False   # Require user approval for safety
+        )
+
+        agent = AgentFactory().create_agent(config=agent_config)
+        logger.info(f"Agentic Software Engineer instance created: {agent.agent_id}")
+
+        # 4. Run the agent in an interactive CLI session.
+        logger.info(f"Starting interactive session for agent {agent.agent_id}...")
+        initial_prompt = f"Hello! I'm ready to work. My current working directory is `{workspace_path}`. What's the first task?"
+        await agent_cli.run(agent=agent, initial_prompt=initial_prompt, show_tool_logs=not args.no_tool_logs)
+        logger.info(f"Interactive session for agent {agent.agent_id} finished.")
+
+    except Exception as e:
+        logger.error(f"An error occurred during the agent workflow: {e}", exc_info=True)
+    
+    logger.info("--- Agentic Software Engineer Example Finished ---")
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Run the Agentic Software Engineer interactively.")
+    parser.add_argument("--llm-model", type=str, default="gemini-2.0-flash-", help=f"The LLM model identifier to use. Call --help-models for list.")
+    parser.add_argument("--workspace-path", type=str, default="./agent_workspace", help="Path to the agent's working directory. (Default: ./agent_workspace)")
+    parser.add_argument("--help-models", action="store_true", help="Display available LLM models and exit.")
+    parser.add_argument("--debug", action="store_true", help="Enable debug logging.")
+    parser.add_argument("--agent-log-file", type=str, default="./agent_logs_swe.txt", 
+                       help="Path to the log file for autobyteus.* library logs. (Default: ./agent_logs_swe.txt)")
+    parser.add_argument("--no-tool-logs", action="store_true", 
+                        help="Disable display of [Tool Log (...)] messages on the console by the agent_cli.")
+
+    if "--help-models" in sys.argv:
+        try:
+            LLMFactory.ensure_initialized() 
+            print("Available LLM Models (use the 'Identifier' with --llm-model):")
+            all_models = sorted(list(LLMModel), key=lambda m: m.model_identifier)
+            if not all_models:
+                print("  No models found.")
+            for model in all_models:
+                print(f"  - Display Name: {model.name:<30} Identifier: {model.model_identifier}")
+        except Exception as e:
+            print(f"Error listing models: {e}")
+        sys.exit(0)
+
+    parsed_args = parser.parse_args()
+    
+    setup_logging(parsed_args)
+    check_required_env_vars()
+
+    try:
+        asyncio.run(main(parsed_args))
+    except (KeyboardInterrupt, SystemExit):
+        logger.info("Script interrupted by user. Exiting.")
+    except Exception as e:
+        logger.error(f"An unhandled error occurred at the top level: {e}", exc_info=True)
+    finally:
+        logger.info("Exiting script.")

examples/run_poem_writer.py

@@ -39,7 +39,7 @@ try:
     from autobyteus.llm.llm_factory import default_llm_factory, LLMFactory
     from autobyteus.agent.factory.agent_factory import AgentFactory
     from autobyteus.cli import agent_cli
-    from autobyteus.tools.file.file_writer import file_writer
+    from autobyteus.tools.file.write_file import write_file
     # Import core workspace and schema components from the library
     from autobyteus.agent.workspace import BaseAgentWorkspace, WorkspaceConfig
     from autobyteus.utils.parameter_schema import ParameterSchema, ParameterDefinition, ParameterType
@@ -176,8 +176,8 @@ async def main(args: argparse.Namespace):
     workspace_base_path.mkdir(parents=True, exist_ok=True)
     logger.info(f"Agent will be configured with a local workspace at: {workspace_base_path}")
 
-    # The file_writer tool is an instance ready to be used
-    tools_for_agent = [file_writer]
+    # The write_file tool is an instance ready to be used
+    tools_for_agent = [write_file]
     
     # UPDATED: The system prompt now provides context about the workspace.
     system_prompt = (

autobyteus/person/examples/sample_persons.py

@@ -1,14 +0,0 @@
-from autobyteus.person.examples.sample_roles import RESEARCHER_ROLE, WRITER_ROLE
-from autobyteus.person.person import Person
-
-ANNA = Person(
-    name="Anna",
-    role=RESEARCHER_ROLE,
-    characteristics=["detail-oriented", "analytical", "curious"]
-)
-
-RYAN = Person(
-    name="Ryan",
-    role=WRITER_ROLE,
-    characteristics=["creative", "empathetic", "articulate"]
-)

autobyteus/person/examples/sample_roles.py

@@ -1,14 +0,0 @@
-from autobyteus.person.role import Role
-
-
-RESEARCHER_ROLE = Role(
-    name="Researcher",
-    skills=["data analysis", "literature review", "critical thinking"],
-    responsibilities=["gather information", "analyze data", "report findings"]
-)
-
-WRITER_ROLE = Role(
-    name="Writer",
-    skills=["content creation", "editing", "storytelling"],
-    responsibilities=["draft articles", "revise content", "adapt to different styles"]
-)

autobyteus/person/person.py

@@ -1,29 +0,0 @@
-from typing import List
-from autobyteus.person.role import Role
-
-class Person:
-    def __init__(self, name: str, role: Role, characteristics: List[str]):
-        self.name = name
-        self.role = role
-        self.characteristics = characteristics
-        self.tasks = []
-
-    def get_description(self) -> str:
-        characteristics_str = ", ".join(self.characteristics)
-        return (f"Person: {self.name}\n"
-                f"{self.role.get_description()}\n"
-                f"Characteristics: {characteristics_str}")
-
-    def __str__(self) -> str:
-        return f"{self.name} ({self.role.name})"
-
-    def assign_task(self, task):
-        if task not in self.tasks:
-            self.tasks.append(task)
-
-    def unassign_task(self, task):
-        if task in self.tasks:
-            self.tasks.remove(task)
-
-    def get_tasks(self):
-        return self.tasks

autobyteus/person/role.py

@@ -1,14 +0,0 @@
-from typing import List
-
-class Role:
-    def __init__(self, name: str, skills: List[str], responsibilities: List[str]):
-        self.name = name
-        self.skills = skills
-        self.responsibilities = responsibilities
-
-    def get_description(self) -> str:
-        skills_str = ", ".join(self.skills)
-        responsibilities_str = ", ".join(self.responsibilities)
-        return (f"Role: {self.name}\n"
-                f"Skills: {skills_str}\n"
-                f"Responsibilities: {responsibilities_str}")

autobyteus/tools/google_search.py

@@ -1,149 +0,0 @@
-import os
-import json
-import logging
-import aiohttp
-from typing import Optional, TYPE_CHECKING, Any, Dict, List
-
-from autobyteus.tools.base_tool import BaseTool
-from autobyteus.tools.tool_config import ToolConfig
-from autobyteus.utils.parameter_schema import ParameterSchema, ParameterDefinition, ParameterType
-from autobyteus.tools.tool_category import ToolCategory
-
-if TYPE_CHECKING:
-    from autobyteus.agent.context import AgentContext
-
-logger = logging.getLogger(__name__)
-
-class GoogleSearch(BaseTool):
-    """
-    Performs a Google search using the Serper.dev API and returns a structured summary of the results.
-    This tool requires a Serper API key, which should be set in the SERPER_API_KEY environment variable.
-    """
-    CATEGORY = ToolCategory.WEB
-    API_URL = "https://google.serper.dev/search"
-
-    def __init__(self, config: Optional[ToolConfig] = None):
-        super().__init__(config=config)
-        self.api_key: Optional[str] = None
-        
-        if config:
-            self.api_key = config.get('api_key')
-        
-        if not self.api_key:
-            self.api_key = os.getenv("SERPER_API_KEY")
-
-        if not self.api_key:
-            raise ValueError(
-                "GoogleSearch tool requires a Serper API key. "
-                "Please provide it via the 'api_key' config parameter or set the 'SERPER_API_KEY' environment variable."
-            )
-        logger.debug("GoogleSearch (API-based) tool initialized.")
-    
-    @classmethod
-    def get_name(cls) -> str:
-        return "GoogleSearch"
-
-    @classmethod
-    def get_description(cls) -> str:
-        return (
-            "Searches Google for a given query using the Serper API. "
-            "Returns a concise, structured summary of search results, including direct answers and top organic links."
-        )
-
-    @classmethod
-    def get_argument_schema(cls) -> Optional[ParameterSchema]:
-        schema = ParameterSchema()
-        schema.add_parameter(ParameterDefinition(
-            name="query",
-            param_type=ParameterType.STRING,
-            description="The search query string.",
-            required=True
-        ))
-        schema.add_parameter(ParameterDefinition(
-            name="num_results",
-            param_type=ParameterType.INTEGER,
-            description="The number of organic search results to return.",
-            required=False,
-            default_value=5,
-            min_value=1,
-            max_value=10
-        ))
-        return schema
-
-    @classmethod
-    def get_config_schema(cls) -> Optional[ParameterSchema]:
-        schema = ParameterSchema()
-        schema.add_parameter(ParameterDefinition(
-            name="api_key",
-            param_type=ParameterType.STRING,
-            description="The API key for the Serper.dev service. Overrides the SERPER_API_KEY environment variable.",
-            required=False
-        ))
-        return schema
-
-    def _format_results(self, data: Dict[str, Any]) -> str:
-        """Formats the JSON response from Serper into a clean string for an LLM."""
-        summary_parts = []
-        
-        # 1. Answer Box (most important for direct questions)
-        if "answerBox" in data:
-            answer_box = data["answerBox"]
-            title = answer_box.get("title", "")
-            snippet = answer_box.get("snippet") or answer_box.get("answer")
-            summary_parts.append(f"Direct Answer for '{title}':\n{snippet}")
-
-        # 2. Knowledge Graph (for entity information)
-        if "knowledgeGraph" in data:
-            kg = data["knowledgeGraph"]
-            title = kg.get("title", "")
-            description = kg.get("description")
-            summary_parts.append(f"Summary for '{title}':\n{description}")
-
-        # 3. Organic Results (the main search links)
-        if "organic" in data and data["organic"]:
-            organic_results = data["organic"]
-            results_str = "\n".join(
-                f"{i+1}. {result.get('title', 'No Title')}\n"
-                f"   Link: {result.get('link', 'No Link')}\n"
-                f"   Snippet: {result.get('snippet', 'No Snippet')}"
-                for i, result in enumerate(organic_results)
-            )
-            summary_parts.append(f"Search Results:\n{results_str}")
-        
-        if not summary_parts:
-            return "No relevant information found for the query."
-
-        return "\n\n---\n\n".join(summary_parts)
-
-
-    async def _execute(self, context: 'AgentContext', query: str, num_results: int = 5) -> str:
-        logger.info(f"Executing GoogleSearch (API) for agent {context.agent_id} with query: '{query}'")
-        
-        headers = {
-            'X-API-KEY': self.api_key,
-            'Content-Type': 'application/json'
-        }
-        payload = json.dumps({
-            "q": query,
-            "num": num_results
-        })
-
-        try:
-            async with aiohttp.ClientSession() as session:
-                async with session.post(self.API_URL, headers=headers, data=payload) as response:
-                    if response.status == 200:
-                        data = await response.json()
-                        return self._format_results(data)
-                    else:
-                        error_text = await response.text()
-                        logger.error(
-                            f"Serper API returned a non-200 status code: {response.status}. "
-                            f"Response: {error_text}"
-                        )
-                        raise RuntimeError(f"API request failed with status {response.status}: {error_text}")
-        except aiohttp.ClientError as e:
-            logger.error(f"Network error during GoogleSearch API call: {e}", exc_info=True)
-            raise RuntimeError(f"A network error occurred: {e}")
-        except Exception as e:
-            logger.error(f"An unexpected error occurred in GoogleSearch tool: {e}", exc_info=True)
-            raise

autobyteus/tools/image_downloader.py

@@ -1,99 +0,0 @@
-import os
-import aiohttp
-import logging
-from datetime import datetime
-from typing import Optional, TYPE_CHECKING, Any
-
-from autobyteus.tools.base_tool import BaseTool
-from autobyteus.tools.tool_config import ToolConfig 
-from autobyteus.utils.parameter_schema import ParameterSchema, ParameterDefinition, ParameterType 
-from autobyteus.tools.tool_category import ToolCategory
-from PIL import Image
-from io import BytesIO
-from autobyteus.utils.file_utils import get_default_download_folder
-from autobyteus.events.event_types import EventType
-
-if TYPE_CHECKING:
-    from autobyteus.agent.context import AgentContext 
-
-logger = logging.getLogger(__name__)
-
-class ImageDownloader(BaseTool):
-    CATEGORY = ToolCategory.WEB
-    supported_formats = ['.jpeg', '.jpg', '.gif', '.png', '.webp']
-    
-    def __init__(self, config: Optional[ToolConfig] = None):
-        super().__init__(config=config)
-        
-        custom_download_folder = None
-        if config:
-            custom_download_folder = config.get('custom_download_folder')
-        
-        self.default_download_folder = get_default_download_folder()
-        self.download_folder = custom_download_folder or self.default_download_folder
-        self.last_downloaded_image = None
-        
-        # Explicitly subscribe the handler in the constructor
-        self.subscribe(EventType.WEIBO_POST_COMPLETED, self.on_weibo_post_completed)
-
-        logger.debug(f"ImageDownloader initialized with download_folder: {self.download_folder}")
-
-    @classmethod
-    def get_description(cls) -> str:
-        return f"Downloads an image from a given URL. Supported formats: {', '.join(format.upper()[1:] for format in cls.supported_formats)}."
-
-    @classmethod
-    def get_argument_schema(cls) -> Optional[ParameterSchema]:
-        schema = ParameterSchema()
-        schema.add_parameter(ParameterDefinition(name="url", param_type=ParameterType.STRING, description=f"A direct URL to an image file (must end with {', '.join(cls.supported_formats)}).", required=True))
-        schema.add_parameter(ParameterDefinition(name="folder", param_type=ParameterType.STRING, description="Optional. Custom directory path to save this specific image. Overrides instance default.", required=False))
-        return schema
-
-    @classmethod
-    def get_config_schema(cls) -> Optional[ParameterSchema]: 
-        schema = ParameterSchema()
-        schema.add_parameter(ParameterDefinition(name="custom_download_folder", param_type=ParameterType.STRING, description="Custom directory path where downloaded images will be saved by default.", required=False, default_value=None))
-        return schema
-
-    async def _execute(self, context: 'AgentContext', url: str, folder: Optional[str] = None) -> str:
-        current_download_folder = folder or self.download_folder
-        if not any(url.lower().endswith(fmt) for fmt in self.supported_formats):
-            raise ValueError(f"Unsupported image format. URL must end with one of: {', '.join(self.supported_formats)}.")
-
-        try:
-            async with aiohttp.ClientSession() as session:
-                async with session.get(url) as response:
-                    response.raise_for_status() 
-                    image_bytes = await response.read()
-
-            with Image.open(BytesIO(image_bytes)) as img:
-                img.verify() 
-
-            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-            extension = os.path.splitext(url)[1].lower() or ".png"
-
-            filename = f"downloaded_image_{timestamp}{extension}"
-            filepath = os.path.join(current_download_folder, filename)
-
-            os.makedirs(current_download_folder, exist_ok=True)
-            with open(filepath, 'wb') as f:
-                f.write(image_bytes)
-
-            self.last_downloaded_image = filepath 
-            logger.info(f"The image is downloaded and stored at: {filepath}")
-            self.emit(EventType.IMAGE_DOWNLOADED, image_path=filepath)
-            return f"The image is downloaded and stored at: {filepath}"
-        except Exception as e:
-            logger.error(f"Error processing image from {url}: {str(e)}", exc_info=True)
-            raise ValueError(f"Error processing image from {url}: {str(e)}")
-
-    def on_weibo_post_completed(self): # No **kwargs needed due to intelligent dispatch
-        if self.last_downloaded_image and os.path.exists(self.last_downloaded_image):
-            try:
-                os.remove(self.last_downloaded_image)
-                logger.info(f"Removed downloaded image: {self.last_downloaded_image} after Weibo post.")
-            except Exception as e:
-                logger.error(f"Failed to remove downloaded image: {self.last_downloaded_image}. Error: {str(e)}", exc_info=True)
-        else:
-            logger.debug("No last downloaded image to remove or image file not found.")
-        self.last_downloaded_image = None

autobyteus/tools/pdf_downloader.py

@@ -1,89 +0,0 @@
- # This was top-level, keep it there.
-import os
-import logging
-import asyncio 
-import requests 
-from datetime import datetime
-from typing import TYPE_CHECKING, Optional
-
-from autobyteus.tools import tool
-from autobyteus.tools.tool_category import ToolCategory
-from autobyteus.utils.file_utils import get_default_download_folder
-
-if TYPE_CHECKING:
-    from autobyteus.agent.context import AgentContext
-
-logger = logging.getLogger(__name__)
-
-@tool(name="PDFDownloader", category=ToolCategory.WEB)
-async def pdf_downloader( # function name can be pdf_downloader
-    context: 'AgentContext', 
-    url: str, 
-    folder: Optional[str] = None
-) -> str:
-    """
-    Downloads a PDF file from a given URL and saves it locally.
-    'url' is the URL of the PDF.
-    'folder' (optional) is a custom directory to save the PDF. If not given,
-    uses the system's default download folder. Validates Content-Type.
-    """
-    logger.debug(f"Functional PDFDownloader tool for agent {context.agent_id}, URL: {url}, Folder: {folder}")
-    
-    current_download_folder = folder if folder else get_default_download_folder()
-
-    try:
-        loop = asyncio.get_event_loop()
-        response = await loop.run_in_executor(None, lambda: requests.get(url, stream=True, timeout=30))
-        response.raise_for_status()
-
-        content_type = response.headers.get('Content-Type', '').lower()
-        if 'application/pdf' not in content_type:
-            response.close()
-            raise ValueError(f"The URL does not point to a PDF file. Content-Type: {content_type}")
-
-        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-        filename_from_header = None
-        if 'Content-Disposition' in response.headers:
-            import re
-            match = re.search(r'filename=[\'"]?([^\'"\s]+)[\'"]?', response.headers['Content-Disposition'])
-            if match: filename_from_header = match.group(1)
-        
-        if filename_from_header and filename_from_header.lower().endswith(".pdf"):
-            import string
-            valid_chars = "-_.() %s%s" % (string.ascii_letters, string.digits)
-            filename_from_header = ''.join(c for c in filename_from_header if c in valid_chars)[:200]
-            filename = f"{timestamp}_{filename_from_header}"
-        else:
-            filename = f"downloaded_pdf_{timestamp}.pdf"
-
-        save_path = os.path.join(current_download_folder, filename)
-        os.makedirs(current_download_folder, exist_ok=True)
-        
-        def download_and_save_sync():
-            with open(save_path, 'wb') as file_handle:
-                for chunk in response.iter_content(chunk_size=8192):
-                    file_handle.write(chunk)
-            response.close()
-        
-        await loop.run_in_executor(None, download_and_save_sync)
-
-        logger.info(f"PDF successfully downloaded and saved to {save_path}")
-        return f"PDF successfully downloaded and saved to {save_path}"
-    except requests.exceptions.Timeout:
-        logger.error(f"Timeout downloading PDF from {url}", exc_info=True)
-        return f"Error downloading PDF: Timeout occurred for URL {url}"
-    except requests.exceptions.RequestException as e:
-        logger.error(f"Error downloading PDF from {url}: {str(e)}", exc_info=True)
-        return f"Error downloading PDF: {str(e)}"
-    except ValueError as e:
-        logger.error(f"Content type error for PDF from {url}: {str(e)}", exc_info=True)
-        return str(e)
-    except IOError as e:
-        logger.error(f"Error saving PDF to {current_download_folder}: {str(e)}", exc_info=True)
-        return f"Error saving PDF: {str(e)}"
-    except Exception as e:
-        logger.error(f"Unexpected error downloading PDF from {url}: {str(e)}", exc_info=True)
-        return f"An unexpected error occurred: {str(e)}"
-    finally:
-        if 'response' in locals() and hasattr(response, 'close') and response.raw and not response.raw.closed:
-             response.close()