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

autobyteus/tools/usage/parsers/openai_json_tool_usage_parser.py

@@ -1,12 +1,12 @@
 # file: autobyteus/autobyteus/tools/usage/parsers/openai_json_tool_usage_parser.py
 import json
 import logging
-import re
-import uuid
 from typing import TYPE_CHECKING, List, Optional, Any, Dict
 
 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
@@ -15,133 +15,132 @@ logger = logging.getLogger(__name__)
 
 class OpenAiJsonToolUsageParser(BaseToolUsageParser):
     """
-    Parses LLM responses for tool usage commands formatted in the OpenAI style.
-    This parser is flexible and can handle multiple formats:
-    1. The official OpenAI API format with a 'tool_calls' list.
-    2. A raw list of tool call objects.
-    3. Simplified tool calls from fine-tuned models (e.g., {"name": "...", "arguments": {...}}).
-    4. A single tool call object not wrapped in a list.
-    5. Tool calls wrapped in a `{"tool": ...}` structure for prompt consistency.
+    Parses LLM responses for tool usage commands formatted in various JSON
+    styles commonly produced by OpenAI and similar models.
+
+    This parser is highly flexible and robustly handles multiple formats:
+    - A root object with a "tool_calls" or "tools" key containing a list of tool calls.
+    - A root object with a single "tool" key.
+    - A root object that is itself a single tool call.
+    - A raw list of tool calls.
+    - Tool call arguments can be either a JSON object or a stringified JSON.
     """
     def get_name(self) -> str:
         return "openai_json_tool_usage_parser"
 
-    def _extract_json_from_response(self, text: str) -> Optional[str]:
-        match = re.search(r"```(?:json)?\s*([\s\S]+?)\s*```", text)
-        if match:
-            return match.group(1).strip()
-        
-        # Try to find a JSON object or array
-        first_bracket = text.find('[')
-        first_brace = text.find('{')
-
-        if first_brace == -1 and first_bracket == -1:
-            return None
-
-        start_index = -1
-        if first_bracket != -1 and first_brace != -1:
-            start_index = min(first_bracket, first_brace)
-        elif first_bracket != -1:
-            start_index = first_bracket
-        else: # first_brace != -1
-            start_index = first_brace
-
-        json_substring = text[start_index:]
-        try:
-            # Check if the substring is valid JSON
-            json.loads(json_substring)
-            return json_substring
-        except json.JSONDecodeError:
-            logger.debug(f"Found potential start of JSON, but substring was not valid: {json_substring[:100]}")
-            return None
-
     def parse(self, response: 'CompleteResponse') -> List[ToolInvocation]:
+        response_text = response.content
         invocations: List[ToolInvocation] = []
-        response_text = self._extract_json_from_response(response.content)
-        if not response_text:
+        
+        # Use a robust method to find all potential JSON blobs in the text
+        json_blobs = _find_json_blobs(response_text)
+        if not json_blobs:
             logger.debug("No valid JSON object could be extracted from the response content.")
             return invocations
 
-        try:
-            data = json.loads(response_text)
-        except json.JSONDecodeError:
-            logger.debug(f"Could not parse extracted text as JSON. Text: {response_text[:200]}")
-            return invocations
+        for blob in json_blobs:
+            try:
+                data = json.loads(blob)
+                
+                # Determine the structure of the JSON data
+                tool_calls_data: List[Dict[str, Any]] = []
+                if isinstance(data, list):
+                    # Format: [{"function":...}, {"function":...}]
+                    tool_calls_data = data
+                elif isinstance(data, dict):
+                    # Format: {"tool_calls": [...]} or {"tools": [...]}
+                    if "tool_calls" in data and isinstance(data["tool_calls"], list):
+                        tool_calls_data = data["tool_calls"]
+                    elif "tools" in data and isinstance(data["tools"], list):
+                        tool_calls_data = data["tools"]
+                    # Format: {"tool": {...}}
+                    elif "tool" in data and isinstance(data["tool"], dict):
+                        tool_calls_data = [data["tool"]]
+                    # Format: {"function": ...}
+                    else:
+                        tool_calls_data = [data]
+                
+                if not tool_calls_data:
+                    logger.debug(f"JSON response does not match any expected tool call format. Content: {blob[:200]}")
+                    continue
 
-        tool_calls: Optional[List[Any]] = None
-        if isinstance(data, dict):
-            # Standard OpenAI format: check for 'tool_calls', fallback to 'tools'
-            tool_calls = data.get("tool_calls")
-            if not isinstance(tool_calls, list):
-                tool_calls = data.get("tools")
-        elif isinstance(data, list):
-            # The entire response is a list of tool calls
-            tool_calls = data
-            
-        if not isinstance(tool_calls, list):
-            # Handle the case where a single tool call is returned as a dictionary, not in a list.
-            if isinstance(data, dict):
-                 # Check for a 'tool' wrapper. If present, the content is the call.
-                if "tool" in data and isinstance(data.get("tool"), dict):
-                    tool_calls = [data] # The list contains the wrapped object
-                # Otherwise, check for standard function/simplified formats.
-                elif ('name' in data and 'arguments' in data) or 'function' in data:
-                    tool_calls = [data]
-        
-        if not isinstance(tool_calls, list):
-            logger.warning(f"Expected a list of tool calls, but couldn't find one in the response. Data type: {type(data)}. Skipping.")
-            return invocations
+                for call_data in tool_calls_data:
+                    invocation = self._parse_tool_call_object(call_data)
+                    if invocation:
+                        invocations.append(invocation)
 
-        for call_data in tool_calls:
-            if not isinstance(call_data, dict):
-                logger.debug(f"Skipping non-dict item in tool_calls: {call_data}")
+            except json.JSONDecodeError:
+                # This can happen if a blob is not a tool call (e.g., just example JSON).
+                # We can safely ignore these.
+                logger.debug(f"Could not parse extracted text as JSON in {self.get_name()}. Blob: {blob[:200]}")
                 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: {e}. Blob: {blob[:200]}"
+                logger.error(error_msg, exc_info=True)
+                raise ToolUsageParseException(error_msg, original_exception=e)
+
+        return invocations
 
-            # Handle if the call is wrapped in a 'tool' key.
-            # This makes the parser compatible with the new example format.
-            if "tool" in call_data and isinstance(call_data.get("tool"), dict):
-                call_data = call_data["tool"]
+    def _parse_tool_call_object(self, call_data: Dict[str, Any]) -> Optional[ToolInvocation]:
+        """
+        Parses a single tool call object, which can have various structures.
+        - {"function": {"name": str, "arguments": str_json_or_dict}}
+        - {"name": str, "arguments": dict}
+        """
+        if not isinstance(call_data, dict):
+            logger.debug(f"Skipping non-dictionary item in tool call list: {call_data}")
+            return None
 
-            # A tool call ID is required for tracking, but the model may not provide one.
-            # If it's missing, we generate one.
-            tool_id = call_data.get("id") or f"call_{uuid.uuid4().hex}"
-            
-            # The tool call can be in the full format `{"function": ...}` or a simplified `{"name": ...}`.
-            function_data: Optional[Dict] = call_data.get("function")
-            if not isinstance(function_data, dict):
-                # If 'function' key is missing, assume simplified format where call_data is the function data.
-                function_data = call_data
-            
+        function_data: Optional[Dict] = call_data.get("function")
+        if isinstance(function_data, dict):
+            # Standard OpenAI format: {"function": {"name": ..., "arguments": ...}}
             tool_name = function_data.get("name")
             arguments_raw = function_data.get("arguments")
+        else:
+            # Handle flattened format: {"name": ..., "arguments": ...}
+            tool_name = call_data.get("name")
+            arguments_raw = call_data.get("arguments")
 
-            if not tool_name:
-                logger.debug(f"Skipping malformed function data (missing 'name'): {function_data}")
-                continue
+        if not tool_name or not isinstance(tool_name, str):
+            logger.debug(f"Skipping malformed tool call (missing or invalid 'name'): {call_data}")
+            return None
 
-            arguments: Optional[Dict] = None
-            if isinstance(arguments_raw, str):
-                try:
-                    arguments = json.loads(arguments_raw)
-                except json.JSONDecodeError:
-                    logger.error(f"Failed to parse 'arguments' string for tool '{tool_name}': {arguments_raw}")
-                    continue
-            elif isinstance(arguments_raw, dict):
-                arguments = arguments_raw
-            elif arguments_raw is None:
-                arguments = {} # Treat missing arguments as an empty dictionary
+        arguments: Dict[str, Any]
+        if arguments_raw is None:
+            arguments = {}
+        elif isinstance(arguments_raw, dict):
+            # Arguments are already a dictionary
+            arguments = arguments_raw
+        elif isinstance(arguments_raw, str):
+            # Arguments are a stringified JSON
+            arg_string = arguments_raw.strip()
+            if not arg_string:
+                arguments = {}
             else:
-                logger.debug(f"Skipping function data with invalid 'arguments' type ({type(arguments_raw)}): {function_data}")
-                continue
-
-            if not isinstance(arguments, dict):
-                logger.error(f"Parsed arguments for tool '{tool_name}' is not a dictionary. Got: {type(arguments)}")
-                continue
-                    
-            try:
-                tool_invocation = ToolInvocation(name=tool_name, arguments=arguments, id=tool_id)
-                invocations.append(tool_invocation)
-            except Exception as e:
-                logger.error(f"Unexpected error creating ToolInvocation for tool '{tool_name}' (ID: {tool_id}): {e}", exc_info=True)
-        
-        return invocations
+                try:
+                    parsed_args = json.loads(arg_string)
+                    if not isinstance(parsed_args, dict):
+                        logger.error(f"Parsed 'arguments' string for tool '{tool_name}' must be a dictionary, but got {type(parsed_args)}.")
+                        return None
+                    arguments = parsed_args
+                except json.JSONDecodeError as e:
+                    # If it's a string but not valid JSON, it's a hard error.
+                    raise ToolUsageParseException(
+                        f"Failed to parse 'arguments' string for tool '{tool_name}': {arguments_raw}",
+                        original_exception=e
+                    )
+        else:
+            # Any other type for arguments is invalid
+            logger.error(f"Skipping tool call with invalid 'arguments' type. Expected dict or string, got {type(arguments_raw)}: {call_data}")
+            return None
+                
+        try:
+            # The ToolInvocation constructor will generate a deterministic ID if 'id' is None.
+            tool_invocation = ToolInvocation(name=tool_name, arguments=arguments, id=None)
+            logger.info(f"Successfully parsed OpenAI-style JSON tool invocation for '{tool_name}'.")
+            return tool_invocation
+        except Exception as e:
+            logger.error(f"Unexpected error creating ToolInvocation for tool '{tool_name}': {e}", exc_info=True)
+            return None

{autobyteus-1.1.0.dist-info → autobyteus-1.1.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: autobyteus
-Version: 1.1.0
+Version: 1.1.2
 Summary: Multi-Agent framework
 Home-page: https://github.com/AutoByteus/autobyteus
 Author: Ryan Zheng
@@ -25,12 +25,13 @@ Requires-Dist: boto3
 Requires-Dist: botocore
 Requires-Dist: anthropic==0.37.1
 Requires-Dist: Jinja2
-Requires-Dist: ollama==0.4.5
-Requires-Dist: mistral_common
+Requires-Dist: ollama
+Requires-Dist: mistral_common==1.6.3
+Requires-Dist: mistralai==1.5.2
 Requires-Dist: certifi==2025.4.26
 Requires-Dist: numpy==2.2.5
 Requires-Dist: aiohttp
-Requires-Dist: autobyteus-llm-client==1.1.0
+Requires-Dist: autobyteus-llm-client==1.1.1
 Requires-Dist: brui-core==1.0.8
 Provides-Extra: dev
 Requires-Dist: coverage; extra == "dev"
@@ -66,19 +67,19 @@ Dynamic: summary
 
 # Autobyteus
 
-Autobyteus is an open-source coding assistance tool designed to enhance the software development workflow by making it context-aware. Each step in the workflow is interactive through a user-friendly interface, incorporating the entire software development lifecycle into each stage.
+Autobyteus is an open-source, application-first agentic framework for Python. It is designed to help developers build, test, and deploy complex, stateful, and extensible AI agents by providing a robust architecture and a powerful set of tools.
 
 ## Architecture
 
 Autobyteus is built with a modular, event-driven architecture designed for extensibility and clear separation of concerns. The key components are:
 
--   **Agent Core**: The heart of the system, comprising an `Agent` facade that provides the primary user-facing API. This facade communicates with an `AgentRuntime`, which manages an `AgentWorker` running in a dedicated thread. This design ensures non-blocking agent operations.
--   **Context & Configuration**: Agent behavior is defined through a clear configuration (`AgentConfig`) and its dynamic state is managed in `AgentRuntimeState`. These are bundled into a comprehensive `AgentContext` that is available to all components during runtime, providing a single source of truth for an agent's status and capabilities.
--   **Event-Driven System**: Agents operate on an internal event loop. Actions (like receiving user messages or tool results) are translated into events and placed on internal queues. `EventHandlers` process these events, containing the core logic for how an agent thinks and acts. This decouples logic and makes the system easy to extend.
--   **Pluggable Processors**: The framework uses a pipeline of processors to modify data at key stages. `SystemPromptProcessors` dynamically build the final system prompt (e.g., by injecting tool definitions), `InputProcessors` preprocess user messages, and `LLMResponseProcessors` parse outputs from the language model (e.g., to detect tool usage).
--   **Tooling**: Agents can be extended with `Tools`, which are self-contained capabilities that can be called by the LLM. The system includes built-in tools (like `SendMessageTo` for inter-agent communication) and supports custom tools.
--   **Multi-Agent Systems**: The `AgentGroup` and `AgenticWorkflow` abstractions provide powerful, high-level APIs for orchestrating multiple agents to collaborate on complex tasks.
--   **Remote Agents**: Built-in RPC capabilities allow for communication with agents running in separate processes or on different machines, enabling distributed agent systems.
+-   **Agent Core**: The heart of the system. Each agent is a stateful, autonomous entity that runs as a background process in its own thread, managed by a dedicated `AgentWorker`. This design makes every agent a truly independent entity capable of handling long-running tasks.
+-   **Context & Configuration**: Agent behavior is defined through a static configuration (`AgentConfig`) and its dynamic state is managed in `AgentRuntimeState`. These are bundled into a comprehensive `AgentContext` that is passed to all components, providing a single source of truth.
+-   **Event-Driven System**: Agents operate on an internal `asyncio` event loop. User messages, tool results, and internal signals are handled as events, which are processed by dedicated `EventHandlers`. This decouples logic and makes the system highly extensible.
+-   **Pluggable Processors & Hooks**: The framework provides extension points to inject custom logic. `InputProcessors` and `LLMResponseProcessors` modify data in the main processing pipeline, while `PhaseHooks` allow custom code to run on specific agent lifecycle transitions (e.g., from `BOOTSTRAPPING` to `IDLE`).
+-   **Context-Aware Tooling**: Tools are first-class citizens that receive the agent's full `AgentContext` during execution. This allows tools to be deeply integrated with the agent's state, configuration, and workspace, enabling more intelligent and powerful actions.
+-   **Tool Approval Flow**: The framework has native support for human-in-the-loop workflows. By setting `auto_execute_tools=False` in the agent's configuration, the agent will pause before executing a tool, emit an event requesting permission, and wait for external approval before proceeding.
+-   **MCP Integration**: The framework has native support for the Model Context Protocol (MCP). This allows agents to discover and use tools from external, language-agnostic tool servers, making the ecosystem extremely flexible and ready for enterprise integration.
 
 ## Features