autobyteus 1.1.2__py3-none-any.whl → 1.1.4__py3-none-any.whl

autobyteus/llm/api/lmstudio_llm.py

@@ -0,0 +1,37 @@
+import logging
+from autobyteus.llm.models import LLMModel
+from autobyteus.llm.utils.llm_config import LLMConfig
+from autobyteus.llm.api.openai_compatible_llm import OpenAICompatibleLLM
+import os
+
+logger = logging.getLogger(__name__)
+
+class LMStudioLLM(OpenAICompatibleLLM):
+    """
+    LLM class for models served by a local LM Studio instance.
+
+    This class communicates with an LM Studio server, which exposes an OpenAI-compatible API.
+    It expects the LM Studio server to be running at the address specified by the `LMSTUDIO_HOST`
+    environment variable, or at `http://localhost:1234` by default.
+
+    Note: The LM Studio server does not require a real API key. A dummy key "lm-studio" is used
+    by default. If you need to use a different key, you can set the `LMSTUDIO_API_KEY`
+    environment variable.
+    """
+    DEFAULT_LMSTUDIO_HOST = 'http://localhost:1234'
+    
+    def __init__(self, model: LLMModel, llm_config: LLMConfig):
+        lmstudio_host = os.getenv('LMSTUDIO_HOST', self.DEFAULT_LMSTUDIO_HOST)
+        base_url = f"{lmstudio_host}/v1"
+
+        super().__init__(
+            model=model,
+            llm_config=llm_config,
+            api_key_env_var="LMSTUDIO_API_KEY",
+            base_url=base_url,
+            api_key_default="lm-studio"
+        )
+        logger.info(f"LMStudioLLM initialized with model: {self.model.name} and base URL: {base_url}")
+
+    async def cleanup(self):
+        await super().cleanup()

autobyteus/llm/api/openai_compatible_llm.py

@@ -21,12 +21,29 @@ class OpenAICompatibleLLM(BaseLLM, ABC):
         model: LLMModel,
         llm_config: LLMConfig,
         api_key_env_var: str,
-        base_url: str
+        base_url: str,
+        api_key_default: Optional[str] = None
     ):
+        """
+        Initializes an OpenAI-compatible LLM.
+
+        Args:
+            model (LLMModel): The model to use.
+            llm_config (LLMConfig): Configuration for the LLM.
+            api_key_env_var (str): The name of the environment variable for the API key.
+            base_url (str): The base URL for the API.
+            api_key_default (Optional[str], optional): A default API key to use if the
+                                                       environment variable is not set.
+                                                       Defaults to None.
+        """
         api_key = os.getenv(api_key_env_var)
         if not api_key:
-            logger.error(f"{api_key_env_var} environment variable is not set.")
-            raise ValueError(f"{api_key_env_var} environment variable is not set.")
+            if api_key_default:
+                api_key = api_key_default
+                logger.info(f"{api_key_env_var} not set, using default key.")
+            else:
+                logger.error(f"{api_key_env_var} environment variable is not set.")
+                raise ValueError(f"{api_key_env_var} environment variable is not set.")
 
         self.client = OpenAI(api_key=api_key, base_url=base_url)
         logger.info(f"Initialized OpenAI compatible client with base_url: {base_url}")

autobyteus/llm/llm_factory.py

@@ -16,6 +16,7 @@ from autobyteus.llm.api.deepseek_llm import DeepSeekLLM
 from autobyteus.llm.api.grok_llm import GrokLLM
 from autobyteus.llm.api.kimi_llm import KimiLLM
 from autobyteus.llm.ollama_provider import OllamaModelProvider
+from autobyteus.llm.lmstudio_provider import LMStudioModelProvider
 from autobyteus.utils.singleton import SingletonMeta
 
 logger = logging.getLogger(__name__)
@@ -307,6 +308,7 @@ class LLMFactory(metaclass=SingletonMeta):
 
         OllamaModelProvider.discover_and_register()
         AutobyteusModelProvider.discover_and_register()
+        LMStudioModelProvider.discover_and_register()
 
     @staticmethod
     def register_model(model: LLMModel):

autobyteus/llm/lmstudio_provider.py

@@ -0,0 +1,89 @@
+from autobyteus.llm.models import LLMModel
+from autobyteus.llm.api.lmstudio_llm import LMStudioLLM
+from autobyteus.llm.providers import LLMProvider
+from autobyteus.llm.utils.llm_config import LLMConfig, TokenPricingConfig
+from typing import TYPE_CHECKING
+import os
+import logging
+from openai import OpenAI, APIConnectionError, OpenAIError
+from urllib.parse import urlparse
+
+if TYPE_CHECKING:
+    from autobyteus.llm.llm_factory import LLMFactory
+
+logger = logging.getLogger(__name__)
+
+class LMStudioModelProvider:
+    DEFAULT_LMSTUDIO_HOST = 'http://localhost:1234'
+
+    @staticmethod
+    def is_valid_url(url: str) -> bool:
+        """Validate if the provided URL is properly formatted."""
+        try:
+            result = urlparse(url)
+            return all([result.scheme, result.netloc])
+        except Exception:
+            return False
+
+    @staticmethod
+    def discover_and_register():
+        """
+        Discovers models from a local LM Studio instance and registers them with the LLMFactory.
+        """
+        try:
+            from autobyteus.llm.llm_factory import LLMFactory
+            
+            lmstudio_host = os.getenv('LMSTUDIO_HOST', LMStudioModelProvider.DEFAULT_LMSTUDIO_HOST)
+            
+            if not LMStudioModelProvider.is_valid_url(lmstudio_host):
+                logger.error(f"Invalid LM Studio host URL: {lmstudio_host}")
+                return
+
+            base_url = f"{lmstudio_host}/v1"
+            
+            # Use a dummy API key for initialization. LM Studio doesn't require one.
+            client = OpenAI(base_url=base_url, api_key="lm-studio")
+
+            try:
+                response = client.models.list()
+                models = response.data
+            except APIConnectionError as e:
+                logger.warning(
+                    f"Could not connect to LM Studio server at {base_url}. "
+                    "Please ensure LM Studio is running with the server started. "
+                    f"Error: {e.__cause__}"
+                )
+                return
+            except OpenAIError as e:
+                logger.error(f"An error occurred while fetching models from LM Studio: {e}")
+                return
+
+            registered_count = 0
+            for model_info in models:
+                model_id = model_info.id
+                if not model_id:
+                    continue
+                
+                try:
+                    llm_model = LLMModel(
+                        name=model_id,
+                        value=model_id,
+                        provider=LLMProvider.LMSTUDIO,
+                        llm_class=LMStudioLLM,
+                        canonical_name=model_id,
+                        default_config=LLMConfig(
+                            rate_limit=None, # No rate limit for local models by default
+                            token_limit=8192, # A reasonable default
+                            pricing_config=TokenPricingConfig(0.0, 0.0) # Local models are free
+                        )
+                    )
+                    LLMFactory.register_model(llm_model)
+                    registered_count += 1
+                except Exception as e:
+                    logger.warning(f"Failed to register LM Studio model {model_id}: {str(e)}")
+
+            if registered_count > 0:
+                logger.info(f"Successfully registered {registered_count} LM Studio models from {lmstudio_host}")
+
+        except Exception as e:
+            logger.error(f"Unexpected error during LM Studio model discovery: {str(e)}")

autobyteus/llm/providers.py

@@ -13,3 +13,4 @@ class LLMProvider(Enum):
     GROK = "grok"
     AUTOBYTEUS = "autobyteus"
     KIMI = "kimi"
+    LMSTUDIO = "lmstudio"

autobyteus/llm/token_counter/token_counter_factory.py

@@ -36,6 +36,8 @@ def get_token_counter(model: LLMModel, llm: 'BaseLLM') -> BaseTokenCounter:
         return KimiTokenCounter(model, llm)
     elif model.provider == LLMProvider.OLLAMA:
         return OpenAITokenCounter(model, llm)
+    elif model.provider == LLMProvider.LMSTUDIO:
+        return OpenAITokenCounter(model, llm)
     elif model.provider == LLMProvider.GEMINI:
         return OpenAITokenCounter(model, llm)
     else:

autobyteus/tools/__init__.py

@@ -10,6 +10,7 @@ from .base_tool import BaseTool
 from .functional_tool import tool # The @tool decorator
 from .parameter_schema import ParameterSchema, ParameterDefinition, ParameterType
 from .tool_config import ToolConfig # Configuration data object, primarily for class-based tools
+from .tool_origin import ToolOrigin
 from .tool_category import ToolCategory
 
 # --- Re-export specific tools for easier access ---
@@ -48,6 +49,7 @@ __all__ = [
     "ParameterDefinition",
     "ParameterType",
     "ToolConfig",
+    "ToolOrigin",
     "ToolCategory",
 
     # Re-exported functional tool instances

autobyteus/tools/ask_user_input.py

@@ -3,13 +3,14 @@ import logging
 from typing import TYPE_CHECKING
 
 from autobyteus.tools import tool # Main @tool decorator
+from autobyteus.tools.tool_category import ToolCategory
 
 if TYPE_CHECKING:
     from autobyteus.agent.context import AgentContext
 
 logger = logging.getLogger(__name__)
 
-@tool(name="AskUserInput") # Explicit name matching the old class name
+@tool(name="AskUserInput", category=ToolCategory.USER_INTERACTION)
 async def ask_user_input(context: 'AgentContext', request: str) -> str: # Function name can be ask_user_input
     """
     Requests input from the user based on a given prompt and returns the user's textual response.

autobyteus/tools/base_tool.py

@@ -16,6 +16,7 @@ if TYPE_CHECKING:
     from autobyteus.tools.parameter_schema import ParameterSchema
     from autobyteus.tools.tool_config import ToolConfig
     from .tool_state import ToolState
+    from autobyteus.tools.registry import ToolDefinition
 
 logger = logging.getLogger('autobyteus')
 
@@ -26,6 +27,7 @@ class BaseTool(ABC, EventEmitter, metaclass=ToolMeta):
     def __init__(self, config: Optional['ToolConfig'] = None):
         super().__init__()
         self.agent_id: Optional[str] = None
+        self.definition: Optional['ToolDefinition'] = None # Link back to its definition
         # The config is stored primarily for potential use by subclasses or future base features.
         self._config = config
         # Add a dedicated state dictionary for the tool instance

autobyteus/tools/bash/bash_executor.py

@@ -4,13 +4,14 @@ import logging
 from typing import TYPE_CHECKING, Optional
 
 from autobyteus.tools import tool 
+from autobyteus.tools.tool_category import ToolCategory
 
 if TYPE_CHECKING:
     from autobyteus.agent.context import AgentContext
 
 logger = logging.getLogger(__name__)
 
-@tool(name="BashExecutor")
+@tool(name="BashExecutor", category=ToolCategory.SYSTEM)
 async def bash_executor(context: Optional['AgentContext'], command: str, cwd: Optional[str] = None) -> str:
     """
     Executes bash commands and retrieves their standard output.

autobyteus/tools/browser/session_aware/browser_session_aware_navigate_to.py

@@ -1,6 +1,7 @@
 from autobyteus.tools.browser.session_aware.browser_session_aware_tool import BrowserSessionAwareTool
 from autobyteus.tools.browser.session_aware.shared_browser_session import SharedBrowserSession
 from autobyteus.tools.tool_config import ToolConfig
+from autobyteus.tools.tool_category import ToolCategory
 from urllib.parse import urlparse
 from typing import Optional, TYPE_CHECKING, Any
 import logging
@@ -16,6 +17,7 @@ class BrowserSessionAwareNavigateTo(BrowserSessionAwareTool):
     """
     A session-aware tool for navigating to a specified website using a shared browser session.
     """
+    CATEGORY = ToolCategory.WEB
 
     def __init__(self, config: Optional[ToolConfig] = None):
         super().__init__(config=config)

autobyteus/tools/browser/session_aware/browser_session_aware_web_element_trigger.py

@@ -9,6 +9,7 @@ from autobyteus.tools.browser.session_aware.shared_browser_session import Shared
 from autobyteus.tools.browser.session_aware.web_element_action import WebElementAction
 from autobyteus.tools.parameter_schema import ParameterSchema, ParameterDefinition, ParameterType
 from autobyteus.tools.tool_config import ToolConfig
+from autobyteus.tools.tool_category import ToolCategory
 
 if TYPE_CHECKING:
     pass
@@ -19,6 +20,8 @@ class BrowserSessionAwareWebElementTrigger(BrowserSessionAwareTool):
     """
     A session-aware tool to trigger actions on web elements identified by a CSS selector.
     """
+    CATEGORY = ToolCategory.WEB
+    
     def __init__(self, config: Optional[ToolConfig] = None):
         super().__init__(config=config)
         logger.debug("BrowserSessionAwareWebElementTrigger tool initialized.")

autobyteus/tools/browser/session_aware/browser_session_aware_webpage_reader.py

@@ -6,6 +6,7 @@ from autobyteus.tools.browser.session_aware.browser_session_aware_tool import Br
 from autobyteus.tools.browser.session_aware.shared_browser_session import SharedBrowserSession
 from autobyteus.tools.tool_config import ToolConfig 
 from autobyteus.tools.parameter_schema import ParameterSchema, ParameterDefinition, ParameterType 
+from autobyteus.tools.tool_category import ToolCategory
 from autobyteus.utils.html_cleaner import clean, CleaningMode
 
 if TYPE_CHECKING:
@@ -18,6 +19,8 @@ class BrowserSessionAwareWebPageReader(BrowserSessionAwareTool):
     A session-aware tool to read and clean HTML content from the current page
     in a shared browser session.
     """
+    CATEGORY = ToolCategory.WEB
+    
     def __init__(self, config: Optional[ToolConfig] = None): 
         super().__init__(config=config)
         

autobyteus/tools/browser/session_aware/browser_session_aware_webpage_screenshot_taker.py

@@ -7,6 +7,7 @@ from autobyteus.tools.browser.session_aware.browser_session_aware_tool import Br
 from autobyteus.tools.browser.session_aware.shared_browser_session import SharedBrowserSession
 from autobyteus.tools.tool_config import ToolConfig 
 from autobyteus.tools.parameter_schema import ParameterSchema, ParameterDefinition, ParameterType 
+from autobyteus.tools.tool_category import ToolCategory
 
 if TYPE_CHECKING:
     from autobyteus.agent.context import AgentContext 
@@ -17,6 +18,8 @@ class BrowserSessionAwareWebPageScreenshotTaker(BrowserSessionAwareTool):
     """
     A session-aware tool to take a screenshot of the current page in a shared browser session.
     """
+    CATEGORY = ToolCategory.WEB
+    
     def __init__(self, config: Optional[ToolConfig] = None): 
         super().__init__(config=config)
         

autobyteus/tools/browser/standalone/google_search_ui.py

@@ -9,6 +9,7 @@ from typing import Optional, TYPE_CHECKING, Any
 from autobyteus.tools.base_tool import BaseTool
 from autobyteus.tools.tool_config import ToolConfig 
 from autobyteus.tools.parameter_schema import ParameterSchema, ParameterDefinition, ParameterType 
+from autobyteus.tools.tool_category import ToolCategory
 from brui_core.ui_integrator import UIIntegrator 
 from autobyteus.utils.html_cleaner import clean, CleaningMode
 
@@ -22,6 +23,7 @@ class GoogleSearch(BaseTool, UIIntegrator): # Multiple inheritance
     A tool that allows for performing a Google search using Playwright and retrieving the search results.
     Inherits from BaseTool for tool framework compatibility and UIIntegrator for Playwright integration.
     """
+    CATEGORY = ToolCategory.WEB
 
     def __init__(self, config: Optional[ToolConfig] = None):
         BaseTool.__init__(self, config=config)

autobyteus/tools/browser/standalone/navigate_to.py

@@ -1,5 +1,6 @@
 from autobyteus.tools.base_tool import BaseTool
 from autobyteus.tools.tool_config import ToolConfig
+from autobyteus.tools.tool_category import ToolCategory
 from brui_core.ui_integrator import UIIntegrator
 from urllib.parse import urlparse
 from typing import Optional, TYPE_CHECKING, Any
@@ -17,6 +18,7 @@ class NavigateTo(BaseTool, UIIntegrator):
     A standalone tool for navigating to a specified website using Playwright.
     It initializes and closes its own browser instance for each navigation.
     """
+    CATEGORY = ToolCategory.WEB
 
     def __init__(self, config: Optional[ToolConfig] = None):
         BaseTool.__init__(self, config=config)

autobyteus/tools/browser/standalone/web_page_pdf_generator.py

@@ -1,5 +1,6 @@
 from autobyteus.tools.base_tool import BaseTool
 from autobyteus.tools.tool_config import ToolConfig
+from autobyteus.tools.tool_category import ToolCategory
 from brui_core.ui_integrator import UIIntegrator
 import os
 import logging
@@ -18,6 +19,8 @@ class WebPagePDFGenerator(BaseTool, UIIntegrator):
     A class that generates a PDF of a given webpage URL using Playwright.
     Saves the PDF to a specified directory. This is a standalone browser tool.
     """
+    CATEGORY = ToolCategory.WEB
+    
     def __init__(self, config: Optional[ToolConfig] = None): 
         BaseTool.__init__(self, config=config)
         UIIntegrator.__init__(self)

autobyteus/tools/browser/standalone/webpage_image_downloader.py

@@ -1,5 +1,6 @@
 from autobyteus.tools.base_tool import BaseTool
 from autobyteus.tools.tool_config import ToolConfig
+from autobyteus.tools.tool_category import ToolCategory
 from brui_core.ui_integrator import UIIntegrator
 import os
 import logging 
@@ -18,6 +19,8 @@ class WebPageImageDownloader(BaseTool, UIIntegrator):
     A class that downloads images (excluding SVGs and data URIs) from a given webpage URL using Playwright.
     Saves images to a specified directory.
     """
+    CATEGORY = ToolCategory.WEB
+    
     def __init__(self, config: Optional[ToolConfig] = None): 
         BaseTool.__init__(self, config=config)
         UIIntegrator.__init__(self)

autobyteus/tools/browser/standalone/webpage_reader.py

@@ -8,6 +8,7 @@ from typing import Optional, TYPE_CHECKING, Any
 from autobyteus.tools.base_tool import BaseTool
 from autobyteus.tools.tool_config import ToolConfig 
 from autobyteus.tools.parameter_schema import ParameterSchema, ParameterDefinition, ParameterType 
+from autobyteus.tools.tool_category import ToolCategory
 from brui_core.ui_integrator import UIIntegrator 
 from autobyteus.utils.html_cleaner import clean, CleaningMode
 
@@ -20,6 +21,7 @@ class WebPageReader(BaseTool, UIIntegrator):
     """
     A class that reads and cleans the HTML content from a given webpage using Playwright.
     """
+    CATEGORY = ToolCategory.WEB
 
     def __init__(self, config: Optional[ToolConfig] = None):
         BaseTool.__init__(self, config=config)

autobyteus/tools/browser/standalone/webpage_screenshot_taker.py

@@ -2,6 +2,7 @@ from typing import Optional, TYPE_CHECKING, Any
 from autobyteus.tools.base_tool import BaseTool
 from autobyteus.tools.tool_config import ToolConfig
 from autobyteus.tools.parameter_schema import ParameterSchema, ParameterDefinition, ParameterType 
+from autobyteus.tools.tool_category import ToolCategory
 from brui_core.ui_integrator import UIIntegrator 
 import logging 
 import os 
@@ -15,6 +16,8 @@ class WebPageScreenshotTaker(BaseTool, UIIntegrator):
     """
     A class that takes a screenshot of a given webpage using Playwright and saves it.
     """
+    CATEGORY = ToolCategory.WEB
+    
     def __init__(self, config: Optional[ToolConfig] = None):
         BaseTool.__init__(self, config=config)
         UIIntegrator.__init__(self) 

autobyteus/tools/file/file_reader.py

@@ -3,27 +3,54 @@ import logging
 from typing import TYPE_CHECKING
 
 from autobyteus.tools import tool
+from autobyteus.tools.tool_category import ToolCategory
 
 if TYPE_CHECKING:
     from autobyteus.agent.context import AgentContext
 
 logger = logging.getLogger(__name__)
 
-@tool(name="FileReader") # Keep registered name "FileReader"
-async def file_reader(context: 'AgentContext', path: str) -> str: # function name can be same
+@tool(name="FileReader", category=ToolCategory.FILE_SYSTEM)
+async def file_reader(context: 'AgentContext', path: str) -> str:
     """
     Reads content from a specified file.
-    'path' is the absolute or relative path to the file.
+    'path' is the path to the file. If relative, it must be resolved against a configured agent workspace.
+    Raises ValueError if a relative path is given without a valid workspace.
     Raises FileNotFoundError if the file does not exist.
     Raises IOError if file reading fails for other reasons.
     """
-    logger.debug(f"Functional FileReader tool for agent {context.agent_id}, path: {path}")
-    if not os.path.exists(path):
-        raise FileNotFoundError(f"The file at {path} does not exist.")
+    logger.debug(f"Functional FileReader tool for agent {context.agent_id}, initial path: {path}")
+    
+    final_path: str
+    if os.path.isabs(path):
+        final_path = path
+        logger.debug(f"Path '{path}' is absolute. Using it directly.")
+    else:
+        if not context.workspace:
+            error_msg = f"Relative path '{path}' provided, but no workspace is configured for agent '{context.agent_id}'. A workspace is required to resolve relative paths."
+            logger.error(error_msg)
+            raise ValueError(error_msg)
+        
+        base_path = context.workspace.get_base_path()
+        if not base_path or not isinstance(base_path, str):
+            error_msg = f"Agent '{context.agent_id}' has a configured workspace, but it provided an invalid base path ('{base_path}'). Cannot resolve relative path '{path}'."
+            logger.error(error_msg)
+            raise ValueError(error_msg)
+            
+        final_path = os.path.join(base_path, path)
+        logger.debug(f"Path '{path}' is relative. Resolved to '{final_path}' using workspace base path '{base_path}'.")
+
+    # It's good practice to normalize the path to handle things like '..'
+    final_path = os.path.normpath(final_path)
+
+    if not os.path.exists(final_path):
+        raise FileNotFoundError(f"The file at resolved path {final_path} does not exist.")
+        
     try:
-        with open(path, 'r', encoding='utf-8') as file:
+        with open(final_path, 'r', encoding='utf-8') as file:
             content = file.read()
+        logger.info(f"File successfully read from '{final_path}' for agent '{context.agent_id}'.")
         return content
     except Exception as e:
-        logger.error(f"Error reading file {path} for agent {context.agent_id}: {e}", exc_info=True)
-        raise IOError(f"Could not read file at {path}: {str(e)}")
+        logger.error(f"Error reading file from final path '{final_path}' for agent {context.agent_id}: {e}", exc_info=True)
+        raise IOError(f"Could not read file at {final_path}: {str(e)}")

autobyteus/tools/file/file_writer.py

@@ -3,29 +3,57 @@ import logging
 from typing import TYPE_CHECKING
 
 from autobyteus.tools import tool
+from autobyteus.tools.tool_category import ToolCategory
 
 if TYPE_CHECKING:
     from autobyteus.agent.context import AgentContext
 
 logger = logging.getLogger(__name__)
 
-@tool(name="FileWriter")
+@tool(name="FileWriter", category=ToolCategory.FILE_SYSTEM)
 async def file_writer(context: 'AgentContext', path: str, content: str) -> str:
     """
     Creates or overwrites a file with specified content.
-    'path' is the path where the file will be written.
+    'path' is the path where the file will be written. If relative, it must be resolved against a configured agent workspace.
     'content' is the string content to write.
     Creates parent directories if they don't exist.
+    Raises ValueError if a relative path is given without a valid workspace.
     Raises IOError if file writing fails.
     """
-    logger.debug(f"Functional FileWriter tool for agent {context.agent_id}, path: {path}")
+    logger.debug(f"Functional FileWriter tool for agent {context.agent_id}, initial path: {path}")
+    
+    final_path: str
+    if os.path.isabs(path):
+        final_path = path
+        logger.debug(f"Path '{path}' is absolute. Using it directly.")
+    else:
+        if not context.workspace:
+            error_msg = f"Relative path '{path}' provided, but no workspace is configured for agent '{context.agent_id}'. A workspace is required to resolve relative paths."
+            logger.error(error_msg)
+            raise ValueError(error_msg)
+        
+        base_path = context.workspace.get_base_path()
+        if not base_path or not isinstance(base_path, str):
+            error_msg = f"Agent '{context.agent_id}' has a configured workspace, but it provided an invalid base path ('{base_path}'). Cannot resolve relative path '{path}'."
+            logger.error(error_msg)
+            raise ValueError(error_msg)
+            
+        final_path = os.path.join(base_path, path)
+        logger.debug(f"Path '{path}' is relative. Resolved to '{final_path}' using workspace base path '{base_path}'.")
+
     try:
-        dir_path = os.path.dirname(path)
-        if dir_path: # Only if path includes a directory part
+        # It's good practice to normalize the path to handle things like '..'
+        final_path = os.path.normpath(final_path)
+        
+        dir_path = os.path.dirname(final_path)
+        if dir_path:
             os.makedirs(dir_path, exist_ok=True)
-        with open(path, 'w', encoding='utf-8') as file:
+            
+        with open(final_path, 'w', encoding='utf-8') as file:
             file.write(content)
-        return f"File created/updated at {path}"
+            
+        logger.info(f"File successfully written to '{final_path}' for agent '{context.agent_id}'.")
+        return f"File created/updated at {final_path}"
     except Exception as e:
-        logger.error(f"Error writing file {path} for agent {context.agent_id}: {e}", exc_info=True)
-        raise IOError(f"Could not write file at {path}: {str(e)}")
+        logger.error(f"Error writing file to final path '{final_path}' for agent {context.agent_id}: {e}", exc_info=True)
+        raise IOError(f"Could not write file at '{final_path}': {str(e)}")

autobyteus/tools/functional_tool.py

@@ -8,6 +8,7 @@ from autobyteus.tools.base_tool import BaseTool
 from autobyteus.tools.parameter_schema import ParameterSchema, ParameterDefinition, ParameterType
 from autobyteus.tools.tool_config import ToolConfig
 from autobyteus.tools.registry import default_tool_registry, ToolDefinition
+from autobyteus.tools.tool_origin import ToolOrigin
 from autobyteus.tools.tool_category import ToolCategory
 
 if TYPE_CHECKING:
@@ -200,7 +201,8 @@ def tool(
     name: Optional[str] = None,
     description: Optional[str] = None,
     argument_schema: Optional[ParameterSchema] = None,
-    config_schema: Optional[ParameterSchema] = None
+    config_schema: Optional[ParameterSchema] = None,
+    category: str = ToolCategory.GENERAL
 ):
     def decorator(func: Callable) -> FunctionalTool:
         tool_name = name or func.__name__
@@ -227,8 +229,6 @@ def tool(
                 instantiation_config=inst_config.params if inst_config else None
             )
         
-        # The decorator's responsibility is now just to assemble the raw metadata
-        # and create the definition. It does NOT generate usage strings.
         tool_def = ToolDefinition(
             name=tool_name,
             description=tool_desc,
@@ -236,7 +236,8 @@ def tool(
             config_schema=config_schema,
             custom_factory=factory,
             tool_class=None,
-            category=ToolCategory.LOCAL
+            origin=ToolOrigin.LOCAL,
+            category=category
         )
         default_tool_registry.register_tool(tool_def)
         

autobyteus/tools/image_downloader.py

@@ -7,6 +7,7 @@ from typing import Optional, TYPE_CHECKING, Any
 from autobyteus.tools.base_tool import BaseTool
 from autobyteus.tools.tool_config import ToolConfig 
 from autobyteus.tools.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
@@ -18,6 +19,7 @@ if TYPE_CHECKING:
 logger = logging.getLogger(__name__)
 
 class ImageDownloader(BaseTool):
+    CATEGORY = ToolCategory.WEB
     supported_formats = ['.jpeg', '.jpg', '.gif', '.png', '.webp']
     
     def __init__(self, config: Optional[ToolConfig] = None):