autobyteus 1.1.6__py3-none-any.whl → 1.1.8__py3-none-any.whl

autobyteus/task_management/tools/publish_task_plan.py

@@ -4,12 +4,11 @@ import logging
 from typing import TYPE_CHECKING, Optional, Dict, Any
 
 from pydantic import ValidationError
-# No longer need GenerateJsonSchema from pydantic.json_schema
-# from pydantic.json_schema import GenerateJsonSchema
 
 from autobyteus.tools.base_tool import BaseTool
 from autobyteus.tools.tool_category import ToolCategory
 from autobyteus.tools.parameter_schema import ParameterSchema, ParameterDefinition, ParameterType
+from autobyteus.tools.pydantic_schema_converter import pydantic_to_parameter_schema
 from autobyteus.task_management.schemas import TaskPlanDefinitionSchema
 from autobyteus.task_management.converters import TaskPlanConverter, TaskBoardConverter
 
@@ -24,8 +23,6 @@ class PublishTaskPlan(BaseTool):
 
     CATEGORY = ToolCategory.TASK_MANAGEMENT
 
-    # The failing custom InlineSchemaGenerator has been removed.
-
     @classmethod
     def get_name(cls) -> str:
         return "PublishTaskPlan"
@@ -44,11 +41,8 @@ class PublishTaskPlan(BaseTool):
     def get_argument_schema(cls) -> Optional[ParameterSchema]:
         schema = ParameterSchema()
         
-        # CORRECTED IMPLEMENTATION:
-        # A direct, standard call to model_json_schema(). This generates a valid
-        # JSON schema with $refs, which the framework handles correctly.
-        # This completely avoids the TypeError caused by the unsupported 'ref_strategy' argument.
-        object_json_schema = TaskPlanDefinitionSchema.model_json_schema()
+        # Convert the Pydantic model to our native ParameterSchema for the nested object
+        plan_object_schema = pydantic_to_parameter_schema(TaskPlanDefinitionSchema)
         
         schema.add_parameter(ParameterDefinition(
             name="plan",
@@ -59,7 +53,7 @@ class PublishTaskPlan(BaseTool):
                 "Each task must have a unique name within the plan."
             ),
             required=True,
-            object_schema=object_json_schema
+            object_schema=plan_object_schema
         ))
         return schema
 
@@ -83,12 +77,8 @@ class PublishTaskPlan(BaseTool):
             return error_msg
             
         try:
-            # Step 1: The input is now a dictionary, so we can directly validate it.
             plan_definition_schema = TaskPlanDefinitionSchema(**plan)
-
-            # Step 2: Use the dedicated converter to create the internal TaskPlan object.
             final_plan = TaskPlanConverter.from_schema(plan_definition_schema)
-
         except (ValidationError, ValueError) as e:
             error_msg = f"Invalid or inconsistent task plan provided: {e}"
             logger.warning(f"Agent '{context.agent_id}' provided an invalid plan for PublishTaskPlan: {error_msg}")
@@ -100,12 +90,10 @@ class PublishTaskPlan(BaseTool):
 
         if task_board.load_task_plan(final_plan):
             logger.info(f"Agent '{context.agent_id}': Task plan published successfully. Returning new board status.")
-            # Convert the new state of the board back to an LLM-friendly schema and return it.
             status_report_schema = TaskBoardConverter.to_schema(task_board)
             if status_report_schema:
                 return status_report_schema.model_dump_json(indent=2)
             else:
-                # This is a fallback case, shouldn't happen right after a successful load.
                 return "Task plan published successfully, but could not generate status report."
         else:
             error_msg = "Failed to load task plan onto the board. This can happen if the board implementation rejects the plan."

autobyteus/task_management/tools/update_task_status.py

@@ -6,6 +6,7 @@ from pydantic import ValidationError
 from autobyteus.tools.base_tool import BaseTool
 from autobyteus.tools.tool_category import ToolCategory
 from autobyteus.tools.parameter_schema import ParameterSchema, ParameterDefinition, ParameterType
+from autobyteus.tools.pydantic_schema_converter import pydantic_to_parameter_schema
 from autobyteus.task_management.base_task_board import TaskStatus
 from autobyteus.task_management.deliverable import FileDeliverable
 from autobyteus.task_management.schemas import FileDeliverableSchema
@@ -53,14 +54,11 @@ class UpdateTaskStatus(BaseTool):
             param_type=ParameterType.ARRAY,
             description="Optional. A list of file deliverables to submit for this task, typically when status is 'completed'. Each deliverable must include a file_path and a summary.",
             required=False,
-            array_item_schema=FileDeliverableSchema.model_json_schema()
+            array_item_schema=pydantic_to_parameter_schema(FileDeliverableSchema)
         ))
         return schema
 
     async def _execute(self, context: 'AgentContext', task_name: str, status: str, deliverables: Optional[List[Dict[str, Any]]] = None) -> str:
-        """
-        Executes the tool to update a task's status and optionally submit deliverables.
-        """
         agent_name = context.config.name
         log_msg = f"Agent '{agent_name}' is executing UpdateTaskStatus for task '{task_name}' to status '{status}'"
         if deliverables:
@@ -84,12 +82,7 @@ class UpdateTaskStatus(BaseTool):
             logger.warning(f"Agent '{agent_name}' tried to update task status, but no plan is loaded.")
             return error_msg
 
-        # Find the task by name
-        target_task = None
-        for task in task_board.current_plan.tasks:
-            if task.task_name == task_name:
-                target_task = task
-                break
+        target_task = next((t for t in task_board.current_plan.tasks if t.task_name == task_name), None)
 
         if not target_task:
             error_msg = f"Failed to update status for task '{task_name}'. The task name does not exist on the current plan."
@@ -103,17 +96,11 @@ class UpdateTaskStatus(BaseTool):
             logger.warning(f"Agent '{agent_name}' provided invalid status for UpdateTaskStatus: {status}")
             return f"Error: {error_msg}"
         
-        # --- Process Deliverables FIRST --- (CORRECTED ORDER)
         if deliverables:
             try:
                 for d_data in deliverables:
-                    # Validate and create the internal deliverable object
                     deliverable_schema = FileDeliverableSchema(**d_data)
-                    full_deliverable = FileDeliverable(
-                        **deliverable_schema.model_dump(),
-                        author_agent_name=agent_name
-                    )
-                    # Append to the task object
+                    full_deliverable = FileDeliverable(**deliverable_schema.model_dump(), author_agent_name=agent_name)
                     target_task.file_deliverables.append(full_deliverable)
                 logger.info(f"Agent '{agent_name}' successfully processed and added {len(deliverables)} deliverables to task '{task_name}'.")
             except (ValidationError, TypeError) as e:
@@ -121,8 +108,6 @@ class UpdateTaskStatus(BaseTool):
                 logger.warning(f"Agent '{agent_name}': {error_msg}")
                 return f"Error: {error_msg}"
 
-        # --- Update Status SECOND --- (CORRECTED ORDER)
-        # This will now emit an event with the deliverables already attached to the task.
         if not task_board.update_task_status(target_task.task_id, status_enum, agent_name):
             error_msg = f"Failed to update status for task '{task_name}'. An unexpected error occurred on the task board."
             logger.error(f"Agent '{agent_name}': {error_msg}")

autobyteus/tools/__init__.py

@@ -16,19 +16,18 @@ from .tool_category import ToolCategory
 # --- Re-export specific tools for easier access ---
 
 # Functional tools (decorated functions are now instances)
-from .ask_user_input import ask_user_input
 from .pdf_downloader import pdf_downloader
 from .bash.bash_executor import bash_executor
 from .file.file_reader import file_reader
 from .file.file_writer import file_writer
 
 # General Class-based tools
+from .google_search import GoogleSearch 
 from .image_downloader import ImageDownloader
 from .timer import Timer
 from .multimedia.image_tools import GenerateImageTool, EditImageTool
 
 # Standalone Browser tools
-from .browser.standalone.google_search_ui import GoogleSearch
 from .browser.standalone.navigate_to import NavigateTo as StandaloneNavigateTo # Alias to avoid name clash
 from .browser.standalone.webpage_reader import WebPageReader as StandaloneWebPageReader # Alias
 from .browser.standalone.webpage_screenshot_taker import WebPageScreenshotTaker as StandaloneWebPageScreenshotTaker # Alias
@@ -54,20 +53,19 @@ __all__ = [
     "ToolCategory",
 
     # Re-exported functional tool instances
-    "ask_user_input",
     "pdf_downloader",
     "bash_executor",
     "file_reader",
     "file_writer",
 
     # Re-exported general class-based tools
+    "GoogleSearch",
     "ImageDownloader",
     "Timer",
     "GenerateImageTool",
     "EditImageTool",
 
     # Re-exported Standalone Browser tools
-    "GoogleSearch",
     "StandaloneNavigateTo",
     "StandaloneWebPageReader",
     "StandaloneWebPageScreenshotTaker",

autobyteus/tools/base_tool.py

@@ -2,18 +2,17 @@
 
 import logging
 from abc import ABC, abstractmethod
-from typing import Optional, Any, TYPE_CHECKING, List as TypingList, Dict
-import xml.sax.saxutils
+from typing import Optional, Any, TYPE_CHECKING, List as TypingList, Dict, Union
 
 from autobyteus.events.event_emitter import EventEmitter
-from autobyteus.events.event_types import EventType
+from autobyteus.tools.parameter_schema import ParameterType
 
 from .tool_meta import ToolMeta
 from .tool_state import ToolState
 
 if TYPE_CHECKING:
     from autobyteus.agent.context import AgentContext
-    from autobyteus.tools.parameter_schema import ParameterSchema
+    from autobyteus.tools.parameter_schema import ParameterSchema, ParameterDefinition
     from autobyteus.tools.tool_config import ToolConfig
     from .tool_state import ToolState
     from autobyteus.tools.registry import ToolDefinition
@@ -27,41 +26,115 @@ 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.definition: Optional['ToolDefinition'] = None
         self._config = config
-        # Add a dedicated state dictionary for the tool instance
-        # CHANGED: Use ToolState class for explicit state management.
         self.tool_state: 'ToolState' = ToolState()
         logger.debug(f"BaseTool instance initializing for potential class {self.__class__.__name__}. tool_state initialized.")
 
     @classmethod
     def get_name(cls) -> str:
-        """Returns the registered name of the tool."""
         return cls.__name__
     
     @classmethod
     @abstractmethod
     def get_description(cls) -> str:
-        """Returns the description of the tool."""
         raise NotImplementedError("Subclasses must implement get_description().")
 
     @classmethod
     @abstractmethod
     def get_argument_schema(cls) -> Optional['ParameterSchema']: 
-        """
-        Return a ParameterSchema defining the arguments this tool accepts for execution.
-        Return None if the tool accepts no arguments.
-        """
         raise NotImplementedError("Subclasses must implement get_argument_schema().")
 
     @classmethod
     def get_config_schema(cls) -> Optional['ParameterSchema']: 
+        return None
+
+    def _coerce_argument_types(self, kwargs: Dict[str, Any]) -> Dict[str, Any]:
         """
-        Return the ParameterSchema for tool *instantiation* parameters.
-        This is optional. By default, tools have no instantiation config.
+        Coerces argument values from the parser (often strings) to their proper
+        Python types based on the tool's argument schema.
+        This method is fully recursive to handle nested objects and arrays.
         """
-        return None
+        arg_schema = self.get_argument_schema()
+        if not arg_schema:
+            return kwargs
+
+        return self._coerce_object_recursively(kwargs, arg_schema)
+
+    def _coerce_object_recursively(self, data: Dict[str, Any], schema: 'ParameterSchema') -> Dict[str, Any]:
+        """ Helper to recursively coerce values in an object based on a ParameterSchema. """
+        coerced_data = data.copy()
+        for name, value in data.items():
+            param_def = schema.get_parameter(name)
+            if param_def:
+                coerced_data[name] = self._coerce_value_recursively(value, param_def)
+        return coerced_data
+
+    def _coerce_value_recursively(self, value: Any, param_def: 'ParameterDefinition') -> Any:
+        """ Coerces a single value based on its ParameterDefinition, recursing into complex types. """
+        if value is None:
+            return None
+
+        # 1. Coerce empty string to empty list for ARRAY types. This is a common parser artifact.
+        if param_def.param_type == ParameterType.ARRAY and value == "":
+            return []
+
+        # 2. Recurse into objects
+        if param_def.param_type == ParameterType.OBJECT and param_def.object_schema and isinstance(value, dict):
+            return self._coerce_object_recursively(value, param_def.object_schema)
+
+        # 3. Recurse into arrays.
+        if param_def.param_type == ParameterType.ARRAY and isinstance(value, list):
+            item_schema_dict = param_def.array_item_schema
+            # If items are objects described by a schema, coerce each one.
+            if item_schema_dict and isinstance(item_schema_dict, dict) and item_schema_dict.get("type") == "object":
+                # Create a temporary ParameterSchema for the item type to enable recursion.
+                # This is a simplified conversion for coercion purposes only.
+                from .parameter_schema import ParameterSchema as TempSchema
+                from .parameter_schema import ParameterDefinition as TempDef
+
+                item_param_schema = TempSchema()
+                props = item_schema_dict.get("properties", {})
+                reqs = item_schema_dict.get("required", [])
+                for prop_name, prop_details in props.items():
+                    # This is a simplified conversion and might not capture all details,
+                    # but it's sufficient for recursive coercion.
+                    prop_type_str = prop_details.get("type", "string")
+                    try:
+                        prop_type = ParameterType(prop_type_str)
+                    except ValueError:
+                        prop_type = ParameterType.STRING
+                    
+                    item_param_schema.add_parameter(TempDef(
+                        name=prop_name,
+                        param_type=prop_type,
+                        description=prop_details.get("description", ""),
+                        required=prop_name in reqs,
+                        array_item_schema=prop_details.get("items") # Pass down nested array schemas
+                    ))
+                
+                return [self._coerce_object_recursively(item, item_param_schema) for item in value if isinstance(item, dict)]
+
+            return value # Return list of primitives as is
+
+        # 4. Coerce primitives if they are passed as strings
+        if isinstance(value, str):
+            try:
+                if param_def.param_type == ParameterType.INTEGER:
+                    return int(value)
+                elif param_def.param_type == ParameterType.FLOAT:
+                    return float(value)
+                elif param_def.param_type == ParameterType.BOOLEAN:
+                    lower_val = value.lower()
+                    if lower_val in ["true", "1", "yes"]:
+                        return True
+                    elif lower_val in ["false", "0", "no"]:
+                        return False
+            except (ValueError, TypeError):
+                logger.warning(f"Could not coerce argument '{param_def.name}' with value '{value}' to type {param_def.param_type}. "
+                               f"Passing string value to tool.")
+        
+        return value
 
     def set_agent_id(self, agent_id: str):
         if not isinstance(agent_id, str) or not agent_id:
@@ -71,30 +144,26 @@ class BaseTool(ABC, EventEmitter, metaclass=ToolMeta):
         logger.debug(f"Agent ID '{agent_id}' set for tool instance '{self.__class__.get_name()}'")
 
     async def execute(self, context: 'AgentContext', **kwargs):
-        # In this context, self.get_name() will call the instance-specific method if it exists.
         tool_name = self.get_name()
         if self.agent_id is None:
             self.set_agent_id(context.agent_id)
-        elif self.agent_id != context.agent_id:
-            logger.warning(
-                f"Tool '{tool_name}' current agent_id '{self.agent_id}' differs from "
-                f"calling context's agent_id '{context.agent_id}'. Updating tool's agent_id."
-            )
-            self.set_agent_id(context.agent_id)
+        
+        # Coerce types before validation and execution
+        coerced_kwargs = self._coerce_argument_types(kwargs)
         
         arg_schema = self.get_argument_schema() 
         if arg_schema:
-            is_valid, errors = arg_schema.validate_config(kwargs)
+            is_valid, errors = arg_schema.validate_config(coerced_kwargs)
             if not is_valid:
                 error_message = f"Invalid arguments for tool '{tool_name}': {'; '.join(errors)}"
                 logger.error(error_message)
                 raise ValueError(error_message)
-        elif kwargs: 
-            logger.warning(f"Tool '{tool_name}' does not define an argument schema but received arguments: {kwargs}. These will be passed to _execute.")
+        elif coerced_kwargs: 
+            logger.warning(f"Tool '{tool_name}' does not define an argument schema but received arguments: {coerced_kwargs}. These will be passed to _execute.")
 
-        logger.info(f"Executing tool '{tool_name}' for agent '{self.agent_id}' with args: {kwargs}")
+        logger.info(f"Executing tool '{tool_name}' for agent '{self.agent_id}' with args: {coerced_kwargs}")
         try:
-            result = await self._execute(context=context, **kwargs) 
+            result = await self._execute(context=context, **coerced_kwargs) 
             logger.info(f"Tool '{tool_name}' execution completed successfully for agent '{self.agent_id}'.")
             return result
         except Exception as e:

autobyteus/tools/browser/standalone/__init__.py

@@ -1,5 +1,4 @@
 # This file makes 'standalone' a package under 'browser'.
-# from .google_search_ui import GoogleSearch
 # from .webpage_reader import WebPageReader
 # from .webpage_screenshot_taker import WebPageScreenshotTaker
 # from .navigate_to import NavigateTo

autobyteus/tools/google_search.py

@@ -0,0 +1,149 @@
+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.tools.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