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

autobyteus/tools/file/file_editor.py

@@ -0,0 +1,200 @@
+import os
+import re
+import logging
+from typing import TYPE_CHECKING, List
+
+from autobyteus.tools.functional_tool import tool
+from autobyteus.tools.tool_category import ToolCategory
+
+if TYPE_CHECKING:
+    from autobyteus.agent.context import AgentContext
+
+logger = logging.getLogger(__name__)
+
+_HUNK_HEADER_RE = re.compile(r"^@@ -(?P<old_start>\d+)(?:,(?P<old_count>\d+))? \+(?P<new_start>\d+)(?:,(?P<new_count>\d+))? @@")
+
+class PatchApplicationError(ValueError):
+    """Raised when a unified diff patch cannot be applied to the target file."""
+
+
+def _resolve_file_path(context: 'AgentContext', path: str) -> str:
+    """Resolves an absolute path for the given input, using the agent workspace when needed."""
+    if os.path.isabs(path):
+        final_path = path
+        logger.debug("FileEdit: provided path '%s' is absolute.", path)
+    else:
+        if not context.workspace:
+            error_msg = ("Relative path '%s' provided, but no workspace is configured for agent '%s'. "
+                         "A workspace is required to resolve relative paths.")
+            logger.error(error_msg, path, context.agent_id)
+            raise ValueError(error_msg % (path, context.agent_id))
+        base_path = context.workspace.get_base_path()
+        if not base_path or not isinstance(base_path, str):
+            error_msg = ("Agent '%s' has a configured workspace, but it provided an invalid base path ('%s'). "
+                         "Cannot resolve relative path '%s'.")
+            logger.error(error_msg, context.agent_id, base_path, path)
+            raise ValueError(error_msg % (context.agent_id, base_path, path))
+        final_path = os.path.join(base_path, path)
+        logger.debug("FileEdit: resolved relative path '%s' against workspace base '%s' to '%s'.", path, base_path, final_path)
+
+    normalized_path = os.path.normpath(final_path)
+    logger.debug("FileEdit: normalized path to '%s'.", normalized_path)
+    return normalized_path
+
+
+def _apply_unified_diff(original_lines: List[str], patch: str) -> List[str]:
+    """Applies a unified diff patch to the provided original lines and returns the patched lines."""
+    if not patch or not patch.strip():
+        raise PatchApplicationError("Patch content is empty; nothing to apply.")
+
+    patched_lines: List[str] = []
+    orig_idx = 0
+    patch_lines = patch.splitlines(keepends=True)
+    line_idx = 0
+
+    while line_idx < len(patch_lines):
+        line = patch_lines[line_idx]
+
+        if line.startswith('---') or line.startswith('+++'):
+            logger.debug("FileEdit: skipping diff header line '%s'.", line.strip())
+            line_idx += 1
+            continue
+
+        if not line.startswith('@@'):
+            stripped = line.strip()
+            if stripped == '':
+                line_idx += 1
+                continue
+            raise PatchApplicationError(f"Unexpected content outside of hunk header: '{stripped}'.")
+
+        match = _HUNK_HEADER_RE.match(line)
+        if not match:
+            raise PatchApplicationError(f"Malformed hunk header: '{line.strip()}'.")
+
+        old_start = int(match.group('old_start'))
+        old_count = int(match.group('old_count') or '1')
+        new_start = int(match.group('new_start'))
+        new_count = int(match.group('new_count') or '1')
+        logger.debug("FileEdit: processing hunk old_start=%s old_count=%s new_start=%s new_count=%s.",
+                     old_start, old_count, new_start, new_count)
+
+        target_idx = old_start - 1 if old_start > 0 else 0
+        if target_idx > len(original_lines):
+            raise PatchApplicationError("Patch hunk starts beyond end of file.")
+        if target_idx < orig_idx:
+            raise PatchApplicationError("Patch hunks overlap or are out of order.")
+
+        patched_lines.extend(original_lines[orig_idx:target_idx])
+        orig_idx = target_idx
+
+        line_idx += 1
+        hunk_consumed = 0
+        removed = 0
+        added = 0
+
+        while line_idx < len(patch_lines):
+            hunk_line = patch_lines[line_idx]
+            if hunk_line.startswith('@@'):
+                break
+
+            if hunk_line.startswith('-'):
+                if orig_idx >= len(original_lines):
+                    raise PatchApplicationError("Patch attempts to remove lines beyond file length.")
+                if original_lines[orig_idx] != hunk_line[1:]:
+                    raise PatchApplicationError("Patch removal does not match file content.")
+                orig_idx += 1
+                hunk_consumed += 1
+                removed += 1
+            elif hunk_line.startswith('+'):
+                patched_lines.append(hunk_line[1:])
+                added += 1
+            elif hunk_line.startswith(' '):
+                if orig_idx >= len(original_lines):
+                    raise PatchApplicationError("Patch context exceeds file length.")
+                if original_lines[orig_idx] != hunk_line[1:]:
+                    raise PatchApplicationError("Patch context does not match file content.")
+                patched_lines.append(original_lines[orig_idx])
+                orig_idx += 1
+                hunk_consumed += 1
+            elif hunk_line.startswith('\\'):
+                if hunk_line.strip() == '\':
+                    if patched_lines:
+                        patched_lines[-1] = patched_lines[-1].rstrip('\n')
+                else:
+                    raise PatchApplicationError(f"Unsupported patch directive: '{hunk_line.strip()}'.")
+            elif hunk_line.strip() == '':
+                patched_lines.append(hunk_line)
+            else:
+                raise PatchApplicationError(f"Unsupported patch line: '{hunk_line.strip()}'.")
+
+            line_idx += 1
+
+        consumed_total = hunk_consumed
+        if old_count == 0:
+            if consumed_total != 0:
+                raise PatchApplicationError("Patch expects zero original lines but consumed some context.")
+        else:
+            if consumed_total != old_count:
+                raise PatchApplicationError(
+                    f"Patch expected to consume {old_count} original lines but consumed {consumed_total}.")
+
+        context_lines = consumed_total - removed
+        expected_new_lines = context_lines + added
+        if new_count == 0:
+            if expected_new_lines != 0:
+                raise PatchApplicationError("Patch declares zero new lines but produced changes.")
+        else:
+            if expected_new_lines != new_count:
+                raise PatchApplicationError(
+                    f"Patch expected to produce {new_count} new lines but produced {expected_new_lines}.")
+
+    patched_lines.extend(original_lines[orig_idx:])
+    return patched_lines
+
+
+@tool(name="FileEdit", category=ToolCategory.FILE_SYSTEM)
+async def file_edit(context: 'AgentContext', path: str, patch: str, create_if_missing: bool = False) -> str:
+    """Applies a unified diff patch to update a text file without overwriting unrelated content.
+
+    Args:
+        path: Path to the target file. Relative paths are resolved against the agent workspace when available.
+        patch: Unified diff patch describing the edits to apply.
+        create_if_missing: When True, allows applying a patch that introduces content to a non-existent file.
+
+    Raises:
+        FileNotFoundError: If the file does not exist and create_if_missing is False.
+        PatchApplicationError: If the patch content cannot be applied cleanly.
+        IOError: If file reading or writing fails.
+    """
+    logger.debug("FileEdit: requested edit for agent '%s' on path '%s'.", context.agent_id, path)
+    final_path = _resolve_file_path(context, path)
+
+    dir_path = os.path.dirname(final_path)
+    if dir_path and not os.path.exists(dir_path) and create_if_missing:
+        os.makedirs(dir_path, exist_ok=True)
+
+    file_exists = os.path.exists(final_path)
+    if not file_exists and not create_if_missing:
+        raise FileNotFoundError(f"The file at resolved path {final_path} does not exist.")
+
+    try:
+        original_lines: List[str]
+        if file_exists:
+            with open(final_path, 'r', encoding='utf-8') as source:
+                original_lines = source.read().splitlines(keepends=True)
+        else:
+            original_lines = []
+
+        patched_lines = _apply_unified_diff(original_lines, patch)
+
+        with open(final_path, 'w', encoding='utf-8') as destination:
+            destination.writelines(patched_lines)
+
+        logger.info("FileEdit: successfully applied patch to '%s'.", final_path)
+        return f"File edited successfully at {final_path}"
+    except PatchApplicationError as patch_err:
+        logger.error("FileEdit: failed to apply patch to '%s': %s", final_path, patch_err, exc_info=True)
+        raise patch_err
+    except Exception as exc:  # pragma: no cover - general safeguard
+        logger.error("FileEdit: unexpected error while editing '%s': %s", final_path, exc, exc_info=True)
+        raise IOError(f"Could not edit file at '{final_path}': {exc}")

autobyteus/tools/functional_tool.py

@@ -5,7 +5,7 @@ import asyncio
 from typing import Callable, Optional, Any, Dict, Tuple, Union, get_origin, get_args, List as TypingList, TYPE_CHECKING, Type
 
 from autobyteus.tools.base_tool import BaseTool
-from autobyteus.tools.parameter_schema import ParameterSchema, ParameterDefinition, ParameterType
+from autobyteus.utils.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

autobyteus/tools/google_search.py

@@ -6,7 +6,7 @@ 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.utils.parameter_schema import ParameterSchema, ParameterDefinition, ParameterType
 from autobyteus.tools.tool_category import ToolCategory
 
 if TYPE_CHECKING:

autobyteus/tools/mcp/factory.py

@@ -6,7 +6,7 @@ from .tool import GenericMcpTool
 from autobyteus.tools.factory.tool_factory import ToolFactory
 
 if TYPE_CHECKING:
-    from autobyteus.tools.parameter_schema import ParameterSchema
+    from autobyteus.utils.parameter_schema import ParameterSchema
     from autobyteus.tools.tool_config import ToolConfig
     from autobyteus.tools.base_tool import BaseTool
 

autobyteus/tools/mcp/schema_mapper.py

@@ -2,7 +2,7 @@
 import logging
 from typing import Dict, Any, List, Optional
 
-from autobyteus.tools.parameter_schema import ParameterSchema, ParameterDefinition, ParameterType
+from autobyteus.utils.parameter_schema import ParameterSchema, ParameterDefinition, ParameterType
 
 logger = logging.getLogger(__name__)
 

autobyteus/tools/mcp/tool.py

@@ -3,7 +3,7 @@ import logging
 from typing import Any, Optional, TYPE_CHECKING
 
 from autobyteus.tools.base_tool import BaseTool
-from autobyteus.tools.parameter_schema import ParameterSchema
+from autobyteus.utils.parameter_schema import ParameterSchema
 from .server.proxy import McpServerProxy
 
 if TYPE_CHECKING:

autobyteus/tools/multimedia/__init__.py

@@ -1,8 +1,10 @@
 from .image_tools import GenerateImageTool, EditImageTool
 from .audio_tools import GenerateSpeechTool
+from .media_reader_tool import ReadMediaFile
 
 __all__ = [
     "GenerateImageTool",
     "EditImageTool",
     "GenerateSpeechTool",
+    "ReadMediaFile",
 ]

autobyteus/tools/multimedia/audio_tools.py

@@ -3,7 +3,7 @@ import logging
 from typing import Optional, List
 
 from autobyteus.tools.base_tool import BaseTool
-from autobyteus.tools.parameter_schema import ParameterSchema, ParameterDefinition, ParameterType
+from autobyteus.utils.parameter_schema import ParameterSchema, ParameterDefinition, ParameterType
 from autobyteus.tools.tool_category import ToolCategory
 from autobyteus.multimedia.audio import audio_client_factory, AudioModel, AudioClientFactory
 
@@ -34,24 +34,8 @@ def _build_dynamic_audio_schema(base_params: List[ParameterDefinition], model_en
         logger.error(f"Cannot generate audio tool schema. Check environment and model registry. Error: {e}")
         raise RuntimeError(f"Failed to configure audio tool. Error: {e}")
 
-    config_schema = ParameterSchema()
-    if model.parameter_schema:
-        for name, meta in model.parameter_schema.items():
-            param_type_str = meta.get("type", "string").upper()
-            param_type = getattr(ParameterType, param_type_str, ParameterType.STRING)
-            
-            allowed_values = meta.get("allowed_values")
-            if param_type == ParameterType.STRING and allowed_values:
-                param_type = ParameterType.ENUM
-
-            config_schema.add_parameter(ParameterDefinition(
-                name=name,
-                param_type=param_type,
-                description=meta.get("description", ""),
-                required=False,
-                default_value=meta.get("default"),
-                enum_values=allowed_values
-            ))
+    # The model's parameter schema is now a ParameterSchema object, so we can use it directly.
+    config_schema = model.parameter_schema
 
     schema = ParameterSchema()
     for param in base_params:
@@ -70,6 +54,7 @@ def _build_dynamic_audio_schema(base_params: List[ParameterDefinition], model_en
 
 class GenerateSpeechTool(BaseTool):
     """
+
     An agent tool for generating speech from text using a Text-to-Speech (TTS) model.
     """
     CATEGORY = ToolCategory.MULTIMEDIA
@@ -93,7 +78,12 @@ class GenerateSpeechTool(BaseTool):
             ParameterDefinition(
                 name="prompt",
                 param_type=ParameterType.STRING,
-                description="The text to be converted into spoken audio.",
+                description=(
+                    "The text to be converted into spoken audio. For multi-speaker mode, you must format the prompt "
+                    "with speaker labels that match the speakers defined in 'speaker_mapping'. "
+                    "CRITICAL: Each speaker's dialogue MUST be on a new line. "
+                    "Example: 'Joe: Hello Jane.\\nJane: Hi Joe, how are you?'"
+                ),
                 required=True
             )
         ]

autobyteus/tools/multimedia/image_tools.py

@@ -3,7 +3,7 @@ import logging
 from typing import Optional, List
 
 from autobyteus.tools.base_tool import BaseTool
-from autobyteus.tools.parameter_schema import ParameterSchema, ParameterDefinition, ParameterType
+from autobyteus.utils.parameter_schema import ParameterSchema, ParameterDefinition, ParameterType
 from autobyteus.tools.tool_category import ToolCategory
 from autobyteus.multimedia.image import image_client_factory, ImageModel, ImageClientFactory
 
@@ -34,24 +34,8 @@ def _build_dynamic_image_schema(base_params: List[ParameterDefinition], model_en
         logger.error(f"Cannot generate image tool schema. Check environment and model registry. Error: {e}")
         raise RuntimeError(f"Failed to configure image tool. Error: {e}")
 
-    config_schema = ParameterSchema()
-    if model.parameter_schema:
-        for name, meta in model.parameter_schema.items():
-            param_type_str = meta.get("type", "string").upper()
-            param_type = getattr(ParameterType, param_type_str, ParameterType.STRING)
-            
-            allowed_values = meta.get("allowed_values")
-            if param_type == ParameterType.STRING and allowed_values:
-                param_type = ParameterType.ENUM
-
-            config_schema.add_parameter(ParameterDefinition(
-                name=name,
-                param_type=param_type,
-                description=meta.get("description", ""),
-                required=False,
-                default_value=meta.get("default"),
-                enum_values=allowed_values
-            ))
+    # The model's parameter schema is now a ParameterSchema object, so we can use it directly.
+    config_schema = model.parameter_schema
 
     schema = ParameterSchema()
     for param in base_params:
@@ -84,6 +68,7 @@ class GenerateImageTool(BaseTool):
     def get_description(cls) -> str:
         return (
             "Generates one or more images based on a textual description (prompt) using the system's default image model. "
+            "Can optionally accept reference images to influence the style or content. "
             "Returns a list of URLs to the generated images upon success."
         )
 
@@ -95,17 +80,31 @@ class GenerateImageTool(BaseTool):
                 param_type=ParameterType.STRING,
                 description="A detailed textual description of the image to generate.",
                 required=True
+            ),
+            ParameterDefinition(
+                name="input_image_urls",
+                param_type=ParameterType.STRING,
+                description="Optional. A comma-separated string of URLs to reference images. The generated image will try to match the style or content of these images.",
+                required=False
             )
         ]
         return _build_dynamic_image_schema(base_params, cls.MODEL_ENV_VAR, cls.DEFAULT_MODEL)
 
-    async def _execute(self, context, prompt: str, generation_config: Optional[dict] = None) -> List[str]:
+    async def _execute(self, context, prompt: str, input_image_urls: Optional[str] = None, generation_config: Optional[dict] = None) -> List[str]:
         model_identifier = _get_configured_model_identifier(self.MODEL_ENV_VAR, self.DEFAULT_MODEL)
         logger.info(f"GenerateImageTool executing with configured model '{model_identifier}'.")
         client = None
         try:
+            urls_list = None
+            if input_image_urls:
+                urls_list = [url.strip() for url in input_image_urls.split(',') if url.strip()]
+
             client = image_client_factory.create_image_client(model_identifier=model_identifier)
-            response = await client.generate_image(prompt=prompt, generation_config=generation_config)
+            response = await client.generate_image(
+                prompt=prompt, 
+                input_image_urls=urls_list,
+                generation_config=generation_config
+            )
             
             if not response.image_urls:
                 raise ValueError("Image generation failed to return any image URLs.")
@@ -121,7 +120,7 @@ class EditImageTool(BaseTool):
     An agent tool for editing an existing image using a text prompt and a pre-configured model.
     """
     CATEGORY = ToolCategory.MULTIMEDIA
-    MODEL_ENV_VAR = "DEFAULT_IMAGE_GENERATION_MODEL"
+    MODEL_ENV_VAR = "DEFAULT_IMAGE_EDIT_MODEL"
     DEFAULT_MODEL = "gpt-image-1"
 
     @classmethod

autobyteus/tools/multimedia/media_reader_tool.py

@@ -0,0 +1,117 @@
+# file: autobyteus/autobyteus/tools/multimedia/media_reader_tool.py
+import logging
+import os
+from typing import TYPE_CHECKING, Optional
+
+from autobyteus.tools.base_tool import BaseTool
+from autobyteus.tools.tool_category import ToolCategory
+from autobyteus.utils.parameter_schema import ParameterSchema, ParameterDefinition, ParameterType
+from autobyteus.agent.message.context_file import ContextFile
+
+if TYPE_CHECKING:
+    from autobyteus.agent.context import AgentContext
+    from autobyteus.agent.workspace.base_workspace import BaseAgentWorkspace
+
+logger = logging.getLogger(__name__)
+
+class ReadMediaFile(BaseTool):
+    """
+    A tool that loads a media file (image, audio, video) into the context for
+    the next LLM turn. This allows a multimodal LLM to directly 'see' or 'hear'
+    the file's content. The tool's result is a structured object that the system
+    uses to construct a multimodal prompt, not plain text.
+    """
+    TOOL_NAME = "ReadMediaFile"
+    CATEGORY = ToolCategory.MULTIMEDIA
+
+    @classmethod
+    def get_name(cls) -> str:
+        return cls.TOOL_NAME
+
+    @classmethod
+    def get_description(cls) -> str:
+        return (
+            "Loads a media file (image, audio, video) into the context for the next turn, "
+            "allowing the LLM to directly analyze its content. Use this when you need to 'see' an image, "
+            "'listen' to audio, or 'watch' a video that you know exists in the workspace or file system."
+        )
+
+    @classmethod
+    def get_argument_schema(cls) -> Optional[ParameterSchema]:
+        schema = ParameterSchema()
+        schema.add_parameter(ParameterDefinition(
+            name="file_path",
+            param_type=ParameterType.STRING,
+            description="The absolute path or workspace-relative path to the media file.",
+            required=True
+        ))
+        return schema
+
+    async def _execute(self,
+                       context: 'AgentContext',
+                       file_path: str) -> 'ContextFile':
+        """
+        Resolves the file path and returns a ContextFile object, which signals
+        the system to include this file in the next multimodal LLM prompt.
+        It handles both absolute paths and paths relative to the agent's workspace.
+        """
+        logger.debug(f"Tool '{self.get_name()}': Received request to read media file at '{file_path}'.")
+        
+        absolute_path: str
+        workspace: Optional['BaseAgentWorkspace'] = context.workspace
+
+        if os.path.isabs(file_path):
+            absolute_path = os.path.normpath(file_path)
+            logger.debug(f"Path '{file_path}' is absolute. Using resolved path: '{absolute_path}'.")
+            
+            # Security Note: This allows reading from outside the workspace.
+            # We log a warning if this occurs.
+            if workspace and hasattr(workspace, 'get_base_path'):
+                try:
+                    workspace_root = os.path.abspath(workspace.get_base_path())
+                    resolved_target = os.path.abspath(absolute_path)
+                    if not os.path.commonpath([workspace_root]) == os.path.commonpath([workspace_root, resolved_target]):
+                        logger.warning(
+                            f"Security Note: Tool '{self.get_name()}' is accessing an absolute path "
+                            f"'{absolute_path}' which is outside the agent's workspace '{workspace_root}'."
+                        )
+                except Exception:
+                    # Failsafe if get_base_path has an issue.
+                    pass
+        else:
+            # Handle relative paths, which MUST be resolved against a workspace that supports file paths.
+            if not (workspace and hasattr(workspace, 'get_base_path') and callable(getattr(workspace, 'get_base_path'))):
+                raise ValueError(
+                    f"A relative path '{file_path}' was provided, but the agent's workspace does not support "
+                    "file system path resolution. Please provide an absolute path or configure a suitable workspace."
+                )
+
+            try:
+                base_path = os.path.abspath(workspace.get_base_path())
+                # Securely join the path and resolve it to a final absolute path
+                absolute_path = os.path.abspath(os.path.join(base_path, file_path))
+                
+                # Security Check: Ensure the resolved path is still within the workspace directory.
+                if os.path.commonpath([base_path]) != os.path.commonpath([base_path, absolute_path]):
+                    raise ValueError(f"Security error: Path '{file_path}' attempts to access files outside the agent's workspace.")
+                
+                logger.debug(f"Path '{file_path}' is relative. Resolved against workspace to '{absolute_path}'.")
+
+            except ValueError as e:
+                # Re-raise security errors with more context.
+                logger.error(f"Tool '{self.get_name()}': Security error resolving relative path '{file_path}': {e}")
+                raise
+
+        try:
+            if not os.path.exists(absolute_path) or not os.path.isfile(absolute_path):
+                raise FileNotFoundError(f"The file '{file_path}' does not exist or is not a regular file at the resolved path '{absolute_path}'.")
+            
+            logger.info(f"Tool '{self.get_name()}': Staging file '{absolute_path}' for next LLM turn.")
+            
+            # The ContextFile constructor will automatically infer file_type from the path.
+            # This is the special object that the ToolResultEventHandler will look for.
+            return ContextFile(uri=absolute_path)
+
+        except (ValueError, FileNotFoundError) as e:
+            logger.error(f"Tool '{self.get_name()}': Error processing path '{file_path}': {e}")
+            raise

autobyteus/tools/pydantic_schema_converter.py

@@ -2,7 +2,7 @@
 import logging
 from typing import Type, get_origin, get_args, Union, List, Dict
 from pydantic import BaseModel
-from autobyteus.tools.parameter_schema import ParameterSchema, ParameterDefinition, ParameterType
+from autobyteus.utils.parameter_schema import ParameterSchema, ParameterDefinition, ParameterType
 
 logger = logging.getLogger(__name__)
 

autobyteus/tools/registry/tool_definition.py

@@ -5,7 +5,7 @@ from typing import Dict, Any, List as TypingList, Type, TYPE_CHECKING, Optional,
 
 from autobyteus.llm.providers import LLMProvider
 from autobyteus.tools.tool_config import ToolConfig
-from autobyteus.tools.parameter_schema import ParameterSchema
+from autobyteus.utils.parameter_schema import ParameterSchema
 from autobyteus.tools.tool_origin import ToolOrigin
 # Import default formatters directly to provide convenience methods
 from autobyteus.tools.usage.formatters import (

autobyteus/tools/timer.py

@@ -2,7 +2,7 @@ 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.tools.parameter_schema import ParameterSchema, ParameterDefinition, ParameterType 
+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

autobyteus/tools/tool_meta.py

@@ -4,7 +4,7 @@ from abc import ABCMeta
 from typing import Dict, Any 
 
 from autobyteus.tools.registry import default_tool_registry, ToolDefinition
-from autobyteus.tools.parameter_schema import ParameterSchema
+from autobyteus.utils.parameter_schema import ParameterSchema
 from autobyteus.tools.tool_origin import ToolOrigin
 from autobyteus.tools.tool_category import ToolCategory
 

autobyteus/tools/usage/formatters/default_json_example_formatter.py

@@ -2,7 +2,7 @@
 import json
 from typing import Dict, Any, TYPE_CHECKING, List, Optional, Union
 
-from autobyteus.tools.parameter_schema import ParameterType, ParameterDefinition, ParameterSchema
+from autobyteus.utils.parameter_schema import ParameterType, ParameterDefinition, ParameterSchema
 from .base_formatter import BaseExampleFormatter
 
 if TYPE_CHECKING:

autobyteus/tools/usage/formatters/default_xml_example_formatter.py

@@ -3,7 +3,7 @@ import xml.sax.saxutils
 import re
 from typing import Any, TYPE_CHECKING, List, Optional
 
-from autobyteus.tools.parameter_schema import ParameterType, ParameterDefinition, ParameterSchema
+from autobyteus.utils.parameter_schema import ParameterType, ParameterDefinition, ParameterSchema
 from .base_formatter import BaseExampleFormatter
 
 if TYPE_CHECKING: