some beauty updates

Author: virrius

sgr_agent_core/agent_config.py

@@ -38,12 +38,6 @@ def from_yaml(cls, yaml_path: str) -> Self:
         yaml_path = Path(yaml_path)
         if not yaml_path.exists():
             raise FileNotFoundError(f"Configuration file not found: {yaml_path}")
-
-        # Add config file directory to sys.path for dynamic imports
-        config_dir = str(yaml_path.resolve().parent)
-        if config_dir not in sys.path:
-            sys.path.insert(0, config_dir)
-
         config_data = yaml.safe_load(yaml_path.read_text(encoding="utf-8"))
         main_config_agents = config_data.pop("agents", {})
         if cls._instance is None:
@@ -54,15 +48,11 @@ def from_yaml(cls, yaml_path: str) -> Self:
             cls._initialized = False
             cls._instance = cls(**config_data, agents=cls._instance.agents)
         # agents should be initialized last to allow merging
-        cls._definitions_from_dict({"agents": main_config_agents}, config_dir=config_dir)
+        cls._definitions_from_dict({"agents": main_config_agents})
         return cls._instance
 
     @classmethod
-    def _definitions_from_dict(cls, agents_data: dict, config_dir: str | None = None) -> Self:
-        # Add config directory to sys.path if provided
-        if config_dir and config_dir not in sys.path:
-            sys.path.insert(0, config_dir)
-
+    def _definitions_from_dict(cls, agents_data: dict) -> Self:
         for agent_name, agent_config in agents_data.get("agents", {}).items():
             agent_config["name"] = agent_name
 
@@ -92,14 +82,13 @@ def definitions_from_yaml(cls, agents_yaml_path: str) -> Self:
             ValueError: If YAML file doesn't contain 'agents' key
         """
         agents_yaml_path = Path(agents_yaml_path)
-        config_dir = str(agents_yaml_path.resolve().parent)
-        if config_dir not in sys.path:
-            sys.path.insert(0, config_dir)
+
+        sys.path.append(str(agents_yaml_path.resolve().parent))
         if not agents_yaml_path.exists():
             raise FileNotFoundError(f"Agents definitions file not found: {agents_yaml_path}")
 
         yaml_data = yaml.safe_load(agents_yaml_path.read_text(encoding="utf-8"))
         if not yaml_data.get("agents"):
             raise ValueError(f"Agents definitions file must contain 'agents' key: {agents_yaml_path}")
 
-        return cls._definitions_from_dict(yaml_data, config_dir=config_dir)
+        return cls._definitions_from_dict(yaml_data)

sgr_agent_core/agent_definition.py

@@ -1,7 +1,7 @@
+import importlib.util
 import inspect
 import logging
 import os
-import sys
 from functools import cached_property
 from pathlib import Path
 from typing import Any, Self
@@ -138,56 +138,26 @@ class AgentDefinition(AgentConfig):
 
     @field_validator("base_class", mode="before")
     def base_class_import_points_to_file(cls, v: Any) -> Any:
-        """Ensure ImportString based base_class points to an existing file or
-        package directory to catch a FileError and not interpret it as str
-        class_name.
+        """Ensure ImportString based base_class points to an existing file to
+        catch a FileError and not interpret it as str class_name.
 
         A dotted path indicates an import string (e.g.,
-        my_pkg.module.Class). We map the module portion to either:
-        - A .py file (e.g., my_module.py)
-        - A package directory with __init__.py (e.g., my_module/__init__.py)
-
-        Checks relative to current working directory and sys.path entries
-        (including config file directory).
+        dir.agent.MyAgent). We use importlib to automatically search for
+        the module in sys.path.
         """
         if isinstance(v, str) and "." in v:
             module_parts = v.split(".")
             if len(module_parts) >= 2:
-                module_path = os.sep.join(module_parts[:-1])
-
-                def check_module_exists(base_path: Path) -> bool:
-                    """Check if module exists as file or package directory."""
-                    # Check for .py file
-                    file_candidate = base_path / (module_path + ".py")
-                    if file_candidate.exists():
-                        return True
-
-                    # Check for package directory with __init__.py
-                    package_candidate = base_path / module_path / "__init__.py"
-                    if package_candidate.exists():
-                        return True
-
-                    return False
-
-                # Try to find relative to current working directory first
-                if check_module_exists(Path.cwd()):
-                    return v
-
-                # Try to find relative to sys.path entries (including config directory)
-                for sys_path in sys.path:
-                    if sys_path:
-                        base_path = Path(sys_path)
-                        if check_module_exists(base_path):
-                            return v
-
-                # If not found, raise error with helpful message
-                file_candidate = Path(os.sep.join(module_parts[:-1]) + ".py")
-                package_candidate = Path(os.sep.join(module_parts[:-1])) / "__init__.py"
-                raise FileNotFoundError(
-                    f"base_class import '{v}' points to module '{module_path}', but neither "
-                    f"'{file_candidate}' nor '{package_candidate}' exists. "
-                    f"Checked relative to current directory and sys.path entries."
-                )
+                # Get module path (everything except the class name)
+                module_path = ".".join(module_parts[:-1])
+                # Use importlib to find module in sys.path automatically
+                spec = importlib.util.find_spec(module_path)
+                if spec is None or spec.origin is None:
+                    file_path = Path(*module_parts[:-1]).with_suffix(".py")
+                    raise FileNotFoundError(
+                        f"base_class import '{v}' points to '{file_path}', "
+                        f"but the file could not be found in sys.path"
+                    )
         return v
 
     @model_validator(mode="before")

sgr_agent_core/server/settings.py

@@ -27,7 +27,8 @@ def setup_logging(logging_file: str) -> None:
     """
     logging_config_path = Path(logging_file)
     if not logging_config_path.exists():
-        raise FileNotFoundError(f"Logging config file not found: {logging_config_path}")
+        logger.warning(f"Logging config file not found: {logging_config_path}")
+        return
 
     with open(logging_config_path, "r", encoding="utf-8") as f:
         logging_config = yaml.safe_load(f)