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

autobyteus/tools/timer.py

@@ -1,175 +0,0 @@
-import asyncio
-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 autobyteus.events.event_emitter import EventEmitter 
-from autobyteus.events.event_types import EventType
-import logging 
-
-if TYPE_CHECKING:
-    from autobyteus.agent.context import AgentContext 
-
-logger = logging.getLogger(__name__)
-
-class Timer(BaseTool, EventEmitter): 
-    """
-    A tool that provides timer functionality with configurable duration and event emission.
-    The timer runs independently after being started and emits TIMER_UPDATE events.
-    """
-    CATEGORY = ToolCategory.UTILITY
-
-    def __init__(self, config: Optional[ToolConfig] = None):
-        BaseTool.__init__(self, config=config)
-        EventEmitter.__init__(self) 
-        
-        self.duration: int = 300  
-        self.interval: int = 60   
-        
-        if config:
-            try:
-                self.duration = int(config.get('duration', 300))
-                if not (1 <= self.duration <= 86400): 
-                    logger.warning(f"Timer duration {self.duration} out of bounds (1-86400). Clamping or using default.")
-                    self.duration = max(1, min(self.duration, 86400)) 
-            except ValueError:
-                logger.warning(f"Invalid duration value in config, using default {self.duration}s.")
-            
-            try:
-                self.interval = int(config.get('interval', 60))
-                if not (1 <= self.interval <= 3600): 
-                    logger.warning(f"Timer interval {self.interval} out of bounds (1-3600). Clamping or using default.")
-                    self.interval = max(1, min(self.interval, 3600)) 
-            except ValueError:
-                 logger.warning(f"Invalid interval value in config, using default {self.interval}s.")
-
-        self._is_running: bool = False
-        self._task: Optional[asyncio.Task] = None
-        logger.debug(f"Timer initialized with duration: {self.duration}s, interval: {self.interval}s")
-
-    @classmethod
-    def get_name(cls) -> str:
-        return "start_timer"
-
-    @classmethod
-    def get_description(cls) -> str:
-        return "Sets and runs a timer. Emits TIMER_UPDATE events with remaining time at specified intervals."
-
-    @classmethod
-    def get_argument_schema(cls) -> Optional[ParameterSchema]:
-        schema = ParameterSchema()
-        schema.add_parameter(ParameterDefinition(
-            name="duration",
-            param_type=ParameterType.INTEGER,
-            description="Duration to set for this timer run in seconds.",
-            required=True, 
-            min_value=1,
-            max_value=86400
-        ))
-        schema.add_parameter(ParameterDefinition(
-            name="interval",
-            param_type=ParameterType.INTEGER,
-            description="Interval for emitting timer events in seconds for this run. Overrides instance default.",
-            required=False, 
-            default_value=None, 
-            min_value=1,
-            max_value=3600
-        ))
-        return schema
-
-    @classmethod
-    def get_config_schema(cls) -> Optional[ParameterSchema]: 
-        schema = ParameterSchema()
-        schema.add_parameter(ParameterDefinition(
-            name="duration",
-            param_type=ParameterType.INTEGER,
-            description="Default duration of the timer in seconds if not overridden by execute.",
-            required=False,
-            default_value=300,
-            min_value=1,
-            max_value=86400 
-        ))
-        schema.add_parameter(ParameterDefinition(
-            name="interval",
-            param_type=ParameterType.INTEGER,
-            description="Default interval at which to emit timer events, in seconds, if not overridden by execute.",
-            required=False,
-            default_value=60,
-            min_value=1,
-            max_value=3600
-        ))
-        return schema
-
-    def set_duration(self, duration: int) -> None: 
-        if not (1 <= duration <= 86400):
-            raise ValueError("Duration must be between 1 and 86400 seconds.")
-        self.duration = duration
-
-    def set_interval(self, interval: int) -> None: 
-        if not (1 <= interval <= 3600):
-            raise ValueError("Interval must be between 1 and 3600 seconds.")
-        self.interval = interval
-
-    def start(self, run_duration: Optional[int] = None, run_interval: Optional[int] = None) -> None: 
-        if self._is_running:
-            logger.warning("Timer start called but timer is already running.")
-            return
-
-        current_duration = run_duration if run_duration is not None else self.duration
-        current_interval = run_interval if run_interval is not None else self.interval
-        
-        if current_duration <= 0:
-            raise RuntimeError("Timer duration must be positive and set before starting.")
-        if current_interval <=0:
-            raise RuntimeError("Timer interval must be positive and set.")
-
-        self._is_running = True
-        self._task = asyncio.create_task(self._run_timer_task(current_duration, current_interval))
-        logger.info(f"Timer started for {current_duration}s, events every {current_interval}s.")
-
-    async def _run_timer_task(self, duration: int, interval: int) -> None: 
-        remaining_time = duration
-        try:
-            while remaining_time > 0:
-                self.emit(EventType.TIMER_UPDATE, remaining_time=remaining_time)
-                await asyncio.sleep(min(interval, remaining_time))
-                remaining_time -= interval
-            self.emit(EventType.TIMER_UPDATE, remaining_time=0) 
-        except asyncio.CancelledError:
-            logger.info("Timer task was cancelled.")
-            self.emit(EventType.TIMER_UPDATE, remaining_time=-1, status="cancelled") 
-            raise 
-        finally:
-            self._is_running = False
-            logger.info("Timer task finished.")
-
-    async def _execute(self, context: 'AgentContext', duration: int, interval: Optional[int] = None) -> str: 
-        logger.debug(f"Timer execute called by agent {context.agent_id} with duration: {duration}, interval: {interval}")
-        
-        effective_interval = interval if interval is not None else self.interval
-
-        if self._task and not self._task.done():
-            logger.info("Cancelling previous timer task before starting a new one.")
-            self._task.cancel()
-            try:
-                await self._task
-            except asyncio.CancelledError:
-                logger.debug("Previous timer task successfully cancelled.")
-            self._task = None 
-
-        self.start(run_duration=duration, run_interval=effective_interval) 
-        return f"Timer started for {duration} seconds, emitting events every {effective_interval} seconds."
-
-    async def stop(self) -> None: 
-        if self._task and not self._task.done():
-            logger.info("Stopping timer task...")
-            self._task.cancel()
-            try:
-                await self._task 
-            except asyncio.CancelledError:
-                logger.info("Timer task stopped successfully.")
-            self._task = None
-            self._is_running = False 
-        else:
-            logger.info("Stop called, but no timer task is running or task already done.")

autobyteus/tools/usage/parsers/__init__.py

@@ -1,22 +0,0 @@
-# file: autobyteus/autobyteus/tools/usage/parsers/__init__.py
-"""
-This package contains concrete parser classes that translate an LLM's raw response
-text into structured ToolInvocation objects.
-"""
-from .base_parser import BaseToolUsageParser
-from .provider_aware_tool_usage_parser import ProviderAwareToolUsageParser
-from .default_xml_tool_usage_parser import DefaultXmlToolUsageParser
-from .anthropic_xml_tool_usage_parser import AnthropicXmlToolUsageParser
-from .default_json_tool_usage_parser import DefaultJsonToolUsageParser
-from .openai_json_tool_usage_parser import OpenAiJsonToolUsageParser
-from .gemini_json_tool_usage_parser import GeminiJsonToolUsageParser
-
-__all__ = [
-    "BaseToolUsageParser",
-    "ProviderAwareToolUsageParser",
-    "DefaultXmlToolUsageParser",
-    "AnthropicXmlToolUsageParser",
-    "DefaultJsonToolUsageParser",
-    "OpenAiJsonToolUsageParser",
-    "GeminiJsonToolUsageParser",
-]

autobyteus/tools/usage/parsers/_json_extractor.py

@@ -1,99 +0,0 @@
-import re
-import logging
-from typing import List
-
-logger = logging.getLogger(__name__)
-
-def _find_json_blobs(text: str) -> List[str]:
-    """
-    Robustly finds and extracts all top-level JSON objects or arrays from a string,
-    maintaining their original order of appearance. It handles JSON within
-    markdown-style code blocks (```json ... ```) and inline JSON.
-    
-    Args:
-        text: The string to search for JSON in.
-        
-    Returns:
-        A list of strings, where each string is a valid-looking JSON blob,
-        ordered as they appeared in the input text.
-    """
-    found_blobs = []
-
-    # 1. Find all markdown blobs first and store them with their start positions.
-    markdown_matches = list(re.finditer(r"```(?:json)?\s*([\s\S]+?)\s*```", text))
-    for match in markdown_matches:
-        content = match.group(1).strip()
-        found_blobs.append((match.start(), content))
-    
-    # 2. Create a "masked" version of the text by replacing markdown blocks with spaces.
-    #    This prevents the inline scanner from finding JSON inside them, while preserving indices.
-    masked_text_list = list(text)
-    for match in markdown_matches:
-        for i in range(match.start(), match.end()):
-            masked_text_list[i] = ' '
-    masked_text = "".join(masked_text_list)
-
-    # 3. Scan the masked text for any other JSON using a single pass brace-counter.
-    idx = 0
-    while idx < len(masked_text):
-        start_idx = -1
-        
-        # Find the next opening brace or bracket
-        next_brace = masked_text.find('{', idx)
-        next_bracket = masked_text.find('[', idx)
-
-        if next_brace == -1 and next_bracket == -1:
-            break # No more JSON starts
-        
-        if next_brace != -1 and (next_bracket == -1 or next_brace < next_bracket):
-            start_idx = next_brace
-            start_char, end_char = '{', '}'
-        else:
-            start_idx = next_bracket
-            start_char, end_char = '[', ']'
-
-        brace_count = 1
-        in_string = False
-        is_escaped = False
-        end_idx = -1
-
-        for i in range(start_idx + 1, len(masked_text)):
-            char = masked_text[i]
-            
-            if in_string:
-                if is_escaped:
-                    is_escaped = False
-                elif char == '\\':
-                    is_escaped = True
-                elif char == '"':
-                    in_string = False
-            else:
-                if char == '"':
-                    in_string = True
-                    is_escaped = False
-                elif char == '{' or char == '[':
-                    brace_count += 1
-                elif char == '}' or char == ']':
-                    brace_count -= 1
-            
-            if brace_count == 0:
-                if (start_char == '{' and char == '}') or \
-                   (start_char == '[' and char == ']'):
-                    end_idx = i
-                    break
-        
-        if end_idx != -1:
-            # We found a blob in the masked text, so its indices are correct
-            # for the original text. Extract the blob from the original text.
-            blob = text[start_idx : end_idx + 1]
-            found_blobs.append((start_idx, blob))
-            idx = end_idx + 1
-        else:
-            # No matching end brace found, move on from the start character.
-            idx = start_idx + 1
-
-    # 4. Sort all found blobs by their start position to ensure correct order
-    found_blobs.sort(key=lambda item: item[0])
-    
-    # 5. Return only the content of the blobs
-    return [content for _, content in found_blobs]

autobyteus/tools/usage/parsers/_string_decoders.py

@@ -1,18 +0,0 @@
-# file: autobyteus/autobyteus/tools/usage/parsers/_string_decoders.py
-"""Utility helpers for normalizing string content inside parsed tool payloads."""
-
-from __future__ import annotations
-
-import html
-from typing import Any
-
-
-def decode_html_entities(data: Any) -> Any:
-    """Recursively decode HTML/XML entities in strings within a data structure."""
-    if isinstance(data, dict):
-        return {key: decode_html_entities(value) for key, value in data.items()}
-    if isinstance(data, list):
-        return [decode_html_entities(item) for item in data]
-    if isinstance(data, str):
-        return html.unescape(data)
-    return data

autobyteus/tools/usage/parsers/anthropic_xml_tool_usage_parser.py

@@ -1,10 +0,0 @@
-# file: autobyteus/autobyteus/tools/usage/parsers/anthropic_xml_tool_usage_parser.py
-from .default_xml_tool_usage_parser import DefaultXmlToolUsageParser
-
-class AnthropicXmlToolUsageParser(DefaultXmlToolUsageParser):
-    """
-    Parser for Anthropic models. Anthropic uses XML for tool calls,
-    so this is an alias for the default XML parser.
-    """
-    def get_name(self) -> str:
-        return "anthropic_xml_tool_usage_parser"

autobyteus/tools/usage/parsers/base_parser.py

@@ -1,41 +0,0 @@
-# file: autobyteus/autobyteus/tools/usage/parsers/base_parser.py
-import logging
-from abc import ABC, abstractmethod
-from typing import List, TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from autobyteus.agent.tool_invocation import ToolInvocation
-    from autobyteus.llm.utils.response_types import CompleteResponse
-
-logger = logging.getLogger(__name__)
-
-class BaseToolUsageParser(ABC):
-    """
-    Abstract base class for parsing tool usage from an LLM's response text.
-    These parsers are responsible for extracting structured tool call information.
-    """
-
-    def get_name(self) -> str:
-        """
-        Returns the unique name for this parser.
-        Defaults to the class name.
-        """
-        return self.__class__.__name__
-
-    @abstractmethod
-    def parse(self, response: 'CompleteResponse') -> List['ToolInvocation']:
-        """
-        Parses the LLM's response. If actionable tool calls are found,
-        this method should return a list of ToolInvocation objects.
-
-        Args:
-            response: The CompleteResponse object from the LLM.
-
-        Returns:
-            A list of ToolInvocation objects. Returns an empty list if no
-            valid tool calls are found.
-        """
-        raise NotImplementedError("Subclasses must implement the 'parse' method.")
-
-    def __repr__(self) -> str:
-        return f"<{self.__class__.__name__}>"

autobyteus/tools/usage/parsers/default_json_tool_usage_parser.py

@@ -1,83 +0,0 @@
-# file: autobyteus/autobyteus/tools/usage/parsers/default_json_tool_usage_parser.py
-import json
-import logging
-from typing import Dict, Any, TYPE_CHECKING, List
-
-from ._string_decoders import decode_html_entities
-
-from autobyteus.agent.tool_invocation import ToolInvocation
-from .base_parser import BaseToolUsageParser
-from .exceptions import ToolUsageParseException
-from ._json_extractor import _find_json_blobs
-
-if TYPE_CHECKING:
-    from autobyteus.llm.utils.response_types import CompleteResponse
-
-logger = logging.getLogger(__name__)
-
-class DefaultJsonToolUsageParser(BaseToolUsageParser):
-    """
-    A default parser for tool usage commands formatted as custom JSON.
-    It robustly extracts potential JSON blobs and expects a 'tool' object
-    with 'function' and 'parameters' keys.
-    """
-    def get_name(self) -> str:
-        return "default_json_tool_usage_parser"
-
-    def parse(self, response: 'CompleteResponse') -> List[ToolInvocation]:
-        response_text = response.content
-        json_blobs = _find_json_blobs(response_text)
-        if not json_blobs:
-            return []
-
-        invocations: List[ToolInvocation] = []
-        for blob in json_blobs:
-            try:
-                data = json.loads(blob)
-                
-                # This parser specifically looks for the {"tool": {...}} structure.
-                if isinstance(data, dict) and "tool" in data:
-                    tool_block = data.get("tool")
-                    if not isinstance(tool_block, dict):
-                        continue
-                    
-                    tool_name = tool_block.get("function")
-                    arguments = tool_block.get("parameters")
-
-                    if not tool_name or not isinstance(tool_name, str):
-                        logger.debug(f"Skipping malformed tool block (missing or invalid 'function'): {tool_block}")
-                        continue
-                    
-                    if arguments is None:
-                        arguments = {}
-                    
-                    if not isinstance(arguments, dict):
-                        logger.debug(f"Skipping tool block with invalid 'parameters' type ({type(arguments)}): {tool_block}")
-                        continue
-                    
-                    decoded_arguments = decode_html_entities(arguments)
-                    decoded_tool_name = decode_html_entities(tool_name)
-                    try:
-                        # Pass id=None to trigger deterministic ID generation.
-                        tool_invocation = ToolInvocation(
-                            name=decoded_tool_name,
-                            arguments=decoded_arguments,
-                            id=None,
-                        )
-                        invocations.append(tool_invocation)
-                        logger.info(f"Successfully parsed default JSON tool invocation for '{tool_name}'.")
-                    except Exception as e:
-                        logger.error(f"Unexpected error creating ToolInvocation for tool '{tool_name}': {e}", exc_info=True)
-
-            except json.JSONDecodeError:
-                logger.debug(f"Could not parse extracted text as JSON in {self.get_name()}. Blob: {blob[:200]}")
-                # This is likely not a tool call, so we can ignore it.
-                continue
-            except Exception as e:
-                # If we're here, it's likely a valid JSON but with unexpected structure.
-                # It's safer to raise this for upstream handling.
-                error_msg = f"Unexpected error while parsing JSON blob in {self.get_name()}: {e}. Blob: {blob[:200]}"
-                logger.error(error_msg, exc_info=True)
-                raise ToolUsageParseException(error_msg, original_exception=e)
-        
-        return invocations