glaip-sdk 0.6.19__py3-none-any.whl → 0.7.27__py3-none-any.whl

glaip_sdk/utils/import_resolver.py

@@ -13,6 +13,10 @@ import ast
 import importlib
 from pathlib import Path
 
+from glaip_sdk.utils.tool_detection import is_tool_plugin_decorator
+
+INIT_FILE = "__init__.py"
+
 
 class ImportResolver:
     """Resolves and categorizes Python imports for tool bundling.
@@ -44,6 +48,36 @@ class ImportResolver:
         """
         self.tool_dir = tool_dir
         self._processed_modules: set[str] = set()
+        self._package_root: Path = self._find_package_root(tool_dir)
+
+    def _find_package_root(self, start_path: Path) -> Path:
+        """Find package root using standard project markers.
+
+        Searches upward from start_path for common Python project markers:
+        - pyproject.toml (modern Python standard)
+        - setup.py (legacy setuptools)
+        - .git (version control root)
+
+        Falls back to start_path.parent if no markers found.
+
+        Args:
+            start_path: Starting directory to search from.
+
+        Returns:
+            Path to the identified package root.
+        """
+        # Check current directory and all parents
+        for parent in [start_path, *start_path.parents]:
+            if (parent / "pyproject.toml").exists():
+                return parent
+            if (parent / "setup.py").exists():
+                return parent
+            if (parent / ".git").exists():
+                return parent
+
+        # Fallback: return parent of start_path
+        # This maintains backward compatibility with original behavior
+        return start_path.parent
 
     def categorize_imports(self, tree: ast.AST) -> tuple[list, list]:
         """Categorize imports into local and external.
@@ -61,7 +95,7 @@ class ImportResolver:
         for node in ast.walk(tree):
             if isinstance(node, ast.ImportFrom):
                 if self.is_local_import(node):
-                    module_file = self.resolve_module_path(node.module)
+                    module_file = self._resolve_import_path(node)
                     local_imports.append((node.module, module_file, node))
                 else:
                     external_imports.append(node)
@@ -70,6 +104,25 @@ class ImportResolver:
 
         return local_imports, external_imports
 
+    def _resolve_import_path(self, node: ast.ImportFrom) -> Path:
+        """Resolve import node to file path.
+
+        Handles both absolute and relative imports.
+
+        Args:
+            node: ImportFrom AST node.
+
+        Returns:
+            Path to the module file.
+        """
+        if node.level > 0:
+            return self.resolve_relative_import_path(node)
+
+        if not node.module:
+            return self.tool_dir / INIT_FILE
+
+        return self.resolve_module_path(node.module)
+
     def is_local_import(self, node: ast.ImportFrom) -> bool:
         """Check if import is local to the tool directory.
 
@@ -79,16 +132,83 @@ class ImportResolver:
         Returns:
             True if import is local.
         """
+        # Handle relative imports (level > 0)
+        if node.level > 0:
+            return self._is_local_relative_import(node)
+
+        # Handle absolute imports with no module name
         if not node.module:
             return False
 
-        # Handle package imports
+        # Handle dotted package imports
         if "." in node.module:
             return self._is_local_package_import(node.module)
 
+        # Handle simple module imports
         potential_file = self.tool_dir / f"{node.module}.py"
         return potential_file.exists()
 
+    def _is_local_relative_import(self, node: ast.ImportFrom) -> bool:
+        """Check if a relative import is local.
+
+        Args:
+            node: ImportFrom node with node.level > 0.
+
+        Returns:
+            True if the relative import resolves to a local file.
+        """
+        if node.level == 0:
+            return False
+
+        base_dir = self._calculate_relative_base_dir(node.level)
+        if not base_dir:
+            return False
+
+        if node.module is None:
+            return self._is_init_file_present(base_dir)
+
+        return self._check_module_exists(base_dir, node.module)
+
+    def _calculate_relative_base_dir(self, level: int) -> Path | None:
+        """Calculate base directory for relative import.
+
+        Args:
+            level: Relative import level (1=current, 2=parent, etc.).
+
+        Returns:
+            Base directory path or None if exceeds filesystem root.
+        """
+        base_dir = self.tool_dir
+        for _ in range(level - 1):
+            if base_dir == base_dir.parent:
+                return None
+            base_dir = base_dir.parent
+        return base_dir
+
+    def _is_init_file_present(self, base_dir: Path) -> bool:
+        """Check if __init__.py exists in directory.
+
+        Args:
+            base_dir: Directory to check.
+
+        Returns:
+            True if __init__.py exists.
+        """
+        return (base_dir / INIT_FILE).exists()
+
+    def _check_module_exists(self, base_dir: Path, module: str) -> bool:
+        """Check if module exists in base directory.
+
+        Args:
+            base_dir: Base directory to search from.
+            module: Module name (dotted or simple).
+
+        Returns:
+            True if module file or package exists.
+        """
+        parts = module.split(".")
+        return self._module_parts_exist(base_dir, parts)
+
     def _is_local_package_import(self, module: str) -> bool:
         """Check if a dotted module path is local.
 
@@ -100,29 +220,141 @@ class ImportResolver:
         """
         parts = module.split(".")
 
-        # Case 1: First part matches current directory name
-        if parts[0] == self.tool_dir.name:
-            remaining_parts = parts[1:]
-            if len(remaining_parts) == 1:
-                module_path = self.tool_dir / f"{remaining_parts[0]}.py"
-                if module_path.exists():
-                    return True
-            elif len(remaining_parts) > 1:
-                module_path = self.tool_dir / "/".join(remaining_parts[:-1]) / f"{remaining_parts[-1]}.py"
-                if module_path.exists():
-                    return True
-
-        # Case 2: First part is a subdirectory of tool_dir
+        if self._check_module_in_tool_dir(parts):
+            return True
+
+        if self._check_module_in_subdirectory(parts):
+            return True
+
+        if self._check_module_in_ancestor_packages(parts):
+            return True
+
+        return False
+
+    def _check_module_in_tool_dir(self, parts: list[str]) -> bool:
+        """Check if module is in the current tool directory (Case 1).
+
+        Args:
+            parts: Module path split into components.
+
+        Returns:
+            True if module is found in tool_dir.
+        """
+        if parts[0] != self.tool_dir.name:
+            return False
+
+        remaining_parts = parts[1:]
+        if not remaining_parts:
+            return False
+
+        return self._module_parts_exist(self.tool_dir, remaining_parts)
+
+    def _check_module_in_subdirectory(self, parts: list[str]) -> bool:
+        """Check if module is in a subdirectory of tool_dir (Case 2).
+
+        Args:
+            parts: Module path split into components.
+
+        Returns:
+            True if module is found in a subdirectory.
+        """
         package_dir = self.tool_dir / parts[0]
-        if package_dir.is_dir():
-            module_path = self.tool_dir / "/".join(parts[:-1]) / f"{parts[-1]}.py"
-            if module_path.exists():
-                return True
-            module_path = self.tool_dir / "/".join(parts) / "__init__.py"
-            return module_path.exists()
+        if not package_dir.is_dir():
+            return False
+
+        return self._module_parts_exist(self.tool_dir, parts)
+
+    def _check_module_in_ancestor_packages(self, parts: list[str]) -> bool:
+        """Check if module is in the package root.
+
+        Uses the discovered package root (via project markers) to resolve
+        imports from the package root. Also falls back to directory name
+        matching for backward compatibility.
+
+        Args:
+            parts: Module path split into components.
+
+        Returns:
+            True if module is found in the package root.
+        """
+        # Strategy 1: Check if package root contains the module
+        if self._check_module_in_package_root(parts):
+            return True
+
+        # Strategy 2: Fallback to directory name matching (backward compatibility)
+        return self._check_module_by_directory_name(parts)
+
+    def _check_module_in_package_root(self, parts: list[str]) -> bool:
+        """Check if module exists in the discovered package root.
+
+        Args:
+            parts: Module path split into components.
+
+        Returns:
+            True if module exists in package root.
+        """
+        # Resolve module from package root
+        module_path = self._resolve_from_package_root_path(self._package_root, parts)
+        return module_path.exists()
+
+    def _check_module_by_directory_name(self, parts: list[str]) -> bool:
+        """Check module by matching directory names (legacy fallback).
+
+        Args:
+            parts: Module path split into components.
+
+        Returns:
+            True if module found by directory name matching.
+        """
+        current = self.tool_dir
+
+        while current != current.parent:
+            if parts[0] == current.name:
+                return self._resolve_from_package_root(current, parts)
+            current = current.parent
 
         return False
 
+    def _resolve_from_package_root(self, package_root: Path, parts: list[str]) -> bool:
+        """Resolve module from a found package root directory.
+
+        Args:
+            package_root: The identified package root directory.
+            parts: Module path split into components.
+
+        Returns:
+            True if module exists in the package root.
+        """
+        remaining_parts = parts[1:]
+
+        if not remaining_parts:
+            return (package_root / INIT_FILE).exists()
+
+        return self._module_parts_exist(package_root, remaining_parts)
+
+    def _module_parts_exist(self, base_dir: Path, parts: list[str]) -> bool:
+        """Check if module parts exist as a file or package.
+
+        Args:
+            base_dir: Base directory to search from.
+            parts: Remaining module path components.
+
+        Returns:
+            True if module file or package exists.
+        """
+        if len(parts) == 1:
+            module_file = base_dir / f"{parts[0]}.py"
+            if module_file.exists():
+                return True
+
+        if len(parts) > 1:
+            module_file = base_dir / "/".join(parts[:-1]) / f"{parts[-1]}.py"
+            if module_file.exists():
+                return True
+
+        init_file = base_dir / "/".join(parts) / INIT_FILE
+        return init_file.exists()
+
     def resolve_module_path(self, module_name: str) -> Path:
         """Resolve module name to file path.
 
@@ -136,6 +368,40 @@ class ImportResolver:
             return self._resolve_dotted_module_path(module_name)
         return self.tool_dir / f"{module_name}.py"
 
+    def resolve_relative_import_path(self, node: ast.ImportFrom) -> Path:
+        """Resolve relative import to file path.
+
+        Args:
+            node: ImportFrom node with node.level > 0.
+
+        Returns:
+            Path to the module file.
+
+        Raises:
+            ValueError: If relative import level exceeds directory depth.
+        """
+        base_dir = self._calculate_relative_base_dir(node.level)
+        if base_dir is None:
+            raise ValueError(f"Invalid relative import: level {node.level} exceeds directory depth")
+
+        if node.module is None:
+            return base_dir / INIT_FILE
+
+        return self._resolve_dotted_module_path_from_base(base_dir, node.module)
+
+    def _resolve_dotted_module_path_from_base(self, base_dir: Path, module_name: str) -> Path:
+        """Resolve dotted module path from a specific base directory.
+
+        Args:
+            base_dir: Base directory to resolve from.
+            module_name: Dotted module path (e.g., 'package.module').
+
+        Returns:
+            Path to the module file.
+        """
+        parts = module_name.split(".")
+        return self._build_module_path(base_dir, parts)
+
     def _resolve_dotted_module_path(self, module_name: str) -> Path:
         """Resolve a dotted module path to a file path.
 
@@ -147,25 +413,107 @@ class ImportResolver:
         """
         parts = module_name.split(".")
 
-        # Case 1: First part matches current directory name
-        if parts[0] == self.tool_dir.name:
-            remaining_parts = parts[1:]
-            if len(remaining_parts) == 1:
-                module_path = self.tool_dir / f"{remaining_parts[0]}.py"
-                if module_path.exists():
-                    return module_path
-            elif len(remaining_parts) > 1:
-                module_path = self.tool_dir / "/".join(remaining_parts[:-1]) / f"{remaining_parts[-1]}.py"
-                if module_path.exists():
-                    return module_path
-
-        # Case 2: Standard package/module.py
-        module_path = self.tool_dir / "/".join(parts[:-1]) / f"{parts[-1]}.py"
+        module_path = self._resolve_from_tool_dir(parts)
+        if module_path and module_path.exists():
+            return module_path
+
+        module_path = self._resolve_from_subdir(parts)
         if module_path.exists():
             return module_path
 
-        # Try package/__init__.py
-        return self.tool_dir / "/".join(parts) / "__init__.py"
+        module_path = self._resolve_from_ancestor_packages(parts)
+        if module_path and module_path.exists():
+            return module_path
+
+        return self.tool_dir / "/".join(parts) / INIT_FILE
+
+    def _resolve_from_tool_dir(self, parts: list[str]) -> Path | None:
+        """Resolve module from current tool directory.
+
+        Args:
+            parts: Module path split into components.
+
+        Returns:
+            Path to potential module file, or None if not applicable.
+        """
+        if parts[0] != self.tool_dir.name:
+            return None
+
+        remaining_parts = parts[1:]
+        if not remaining_parts:
+            return self.tool_dir / INIT_FILE
+
+        return self._build_module_path(self.tool_dir, remaining_parts)
+
+    def _resolve_from_subdir(self, parts: list[str]) -> Path:
+        """Resolve module from a subdirectory.
+
+        Args:
+            parts: Module path split into components.
+
+        Returns:
+            Path to potential module file.
+        """
+        return self._build_module_path(self.tool_dir, parts)
+
+    def _resolve_from_ancestor_packages(self, parts: list[str]) -> Path | None:
+        """Resolve module from an ancestor directory (Package Root Traversal).
+
+        Traverses up the directory tree looking for a matching package root.
+
+        Args:
+            parts: Module path split into components.
+
+        Returns:
+            Path to module if found in ancestor, None otherwise.
+        """
+        current = self.tool_dir
+
+        while current != current.parent:
+            if parts[0] == current.name:
+                return self._resolve_from_package_root_path(current, parts)
+            current = current.parent
+
+        return None
+
+    def _resolve_from_package_root_path(self, package_root: Path, parts: list[str]) -> Path:
+        """Build module path from a found package root.
+
+        Args:
+            package_root: The identified package root directory.
+            parts: Module path split into components.
+
+        Returns:
+            Path to potential module file.
+        """
+        remaining_parts = parts[1:]
+
+        if not remaining_parts:
+            return package_root / INIT_FILE
+
+        return self._build_module_path(package_root, remaining_parts)
+
+    def _build_module_path(self, base_dir: Path, parts: list[str]) -> Path:
+        """Build potential module file path from parts.
+
+        Args:
+            base_dir: Base directory to search from.
+            parts: Module path components.
+
+        Returns:
+            Path to potential module file.
+        """
+        if len(parts) == 1:
+            module_path = base_dir / f"{parts[0]}.py"
+            if module_path.exists():
+                return module_path
+
+        if len(parts) > 1:
+            module_path = base_dir / "/".join(parts[:-1]) / f"{parts[-1]}.py"
+            if module_path.exists():
+                return module_path
+
+        return base_dir / "/".join(parts) / INIT_FILE
 
     def format_external_imports(self, external_imports: list) -> list[str]:
         """Format external imports as code strings.
@@ -215,11 +563,49 @@ class ImportResolver:
             True if import should be skipped.
         """
         if isinstance(node, ast.ImportFrom):
-            return node.module and any(node.module.startswith(m) for m in self.EXCLUDED_MODULES)
+            return self._should_skip_import_from(node)
         if isinstance(node, ast.Import):
-            return any(alias.name.startswith(m) for m in self.EXCLUDED_MODULES for alias in node.names)
+            return self._should_skip_regular_import(node)
         return False
 
+    def _should_skip_import_from(self, node: ast.ImportFrom) -> bool:
+        """Check if ImportFrom node should be skipped.
+
+        Args:
+            node: ImportFrom node to check.
+
+        Returns:
+            True if import should be skipped.
+        """
+        if not node.module:
+            return False
+        return self._is_module_excluded(node.module)
+
+    def _should_skip_regular_import(self, node: ast.Import) -> bool:
+        """Check if Import node should be skipped.
+
+        Args:
+            node: Import node to check.
+
+        Returns:
+            True if any alias should be skipped.
+        """
+        return any(self._is_module_excluded(alias.name) for alias in node.names)
+
+    def _is_module_excluded(self, module_name: str) -> bool:
+        """Check if a module name should be excluded.
+
+        Args:
+            module_name: Module name to check.
+
+        Returns:
+            True if module is excluded.
+        """
+        # Exact match for glaip_sdk or match excluded submodules with boundary
+        if module_name == "glaip_sdk":
+            return True
+        return any(module_name == m or module_name.startswith(m + ".") for m in self.EXCLUDED_MODULES)
+
     @staticmethod
     def _build_import_strings(future_imports: list, regular_imports: list) -> list[str]:
         """Build formatted import strings from import nodes.
@@ -381,7 +767,7 @@ class ImportResolver:
             The node if external, None if local.
         """
         if isinstance(node, ast.ImportFrom):
-            if node.module and node.module.startswith("."):
+            if node.level > 0:
                 return None
             temp_resolver = ImportResolver(tool_dir)
             if temp_resolver.is_local_import(node):
@@ -444,15 +830,7 @@ class ImportResolver:
         Returns:
             True if decorator is @tool_plugin.
         """
-        if isinstance(decorator, ast.Name) and decorator.id == "tool_plugin":
-            return True
-        if (
-            isinstance(decorator, ast.Call)
-            and isinstance(decorator.func, ast.Name)
-            and decorator.func.id == "tool_plugin"
-        ):
-            return True
-        return False
+        return is_tool_plugin_decorator(decorator)
 
     @staticmethod
     def _filter_bases(bases: list) -> list:

glaip_sdk/utils/runtime_config.py

@@ -10,6 +10,7 @@ Authors:
 from __future__ import annotations
 
 from typing import TYPE_CHECKING
+from collections.abc import Mapping
 
 from glaip_sdk.utils.resource_refs import is_uuid
 from gllm_core.utils import LoggerManager
@@ -379,14 +380,14 @@ def get_name_from_key(key: object) -> str | None:
     raise ValueError(f"Unable to resolve config key: {key!r}")
 
 
-def normalize_local_config_keys(config: dict[object, object]) -> dict[str, object]:
+def normalize_local_config_keys(config: Mapping[object, object]) -> dict[str, object]:
     """Normalize all keys in a config dict to names for local mode.
 
     Converts instance/class/string keys to string names without using
     registry. UUID keys are skipped with a warning.
 
     Args:
-        config: Dict with instance/class/string keys and any values.
+        config: Dict/Mapping with instance/class/string keys and any values.
 
     Returns:
         Dict with string name keys only. UUID keys are omitted.

glaip_sdk/utils/sync.py

@@ -15,6 +15,7 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, Any
 
+from glaip_sdk.exceptions import ValidationError
 from glaip_sdk.utils.bundler import ToolBundler
 from glaip_sdk.utils.import_resolver import load_class
 from gllm_core.utils import LoggerManager
@@ -94,19 +95,38 @@ def update_or_create_tool(tool_ref: Any) -> Tool:
     tool_name = _extract_tool_name(tool_class)
     tool_description = _extract_tool_description(tool_class)
 
-    # Bundle source code
+    # Bundle source code - try without decorator first (for newer servers 0.1.85+)
+    # If validation fails, retry with decorator for older servers (< 0.1.85)
     bundler = ToolBundler(tool_class)
-    bundled_source = bundler.bundle()
 
-    logger.info("Tool info: name='%s', description='%s...'", tool_name, tool_description[:50])
-    logger.info("Bundled source code: %d characters", len(bundled_source))
-
-    # Use client's upsert method
-    return client.tools.upsert_tool(
-        tool_name,
-        code=bundled_source,
-        description=tool_description,
-    )
+    try:
+        # Try without decorator first (for newer servers where it's optional)
+        bundled_source = bundler.bundle(add_tool_plugin_decorator=False)
+        logger.info("Tool info: name='%s', description='%s...'", tool_name, tool_description[:50])
+        logger.info("Bundled source code (without decorator): %d characters", len(bundled_source))
+
+        # Attempt upload without decorator
+        return client.tools.upsert_tool(
+            tool_name,
+            code=bundled_source,
+            description=tool_description,
+        )
+    except ValidationError as e:
+        # Check if error is about missing @tool_plugin decorator
+        error_message = str(e).lower()
+        if "@tool_plugin decorator" in error_message or "no classes found" in error_message:
+            # Retry with decorator for older servers (< 0.1.85)
+            logger.info("Server requires @tool_plugin decorator, retrying with decorator added")
+            bundled_source = bundler.bundle(add_tool_plugin_decorator=True)
+            logger.info("Bundled source code (with decorator): %d characters", len(bundled_source))
+
+            return client.tools.upsert_tool(
+                tool_name,
+                code=bundled_source,
+                description=tool_description,
+            )
+        # Re-raise if it's a different validation error
+        raise
 
 
 def update_or_create_agent(agent_config: dict[str, Any]) -> Agent: