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

glaip_sdk/tools/base.py

@@ -231,6 +231,9 @@ class Tool:
         Native tools are pre-existing tools on the GL AIP platform
         that don't require uploading (e.g., "time_tool", "web_search").
 
+        For local execution, automatically discovers the corresponding aip_agents.tools
+        class if available. If not found, tool can only be used after deployment.
+
         Args:
             name: The name of the native tool on the platform.
 
@@ -241,7 +244,14 @@ class Tool:
             >>> time_tool = Tool.from_native("time_tool")
             >>> web_search = Tool.from_native("web_search")
         """
-        return cls(name=name, type=ToolType.NATIVE)
+        # Try to discover local implementation for native execution
+        from glaip_sdk.utils.tool_detection import (  # noqa: PLC0415
+            find_aip_agents_tool_class,
+        )
+
+        tool_class = find_aip_agents_tool_class(name)
+
+        return cls(name=name, type=ToolType.NATIVE, tool_class=tool_class)
 
     @classmethod
     def from_langchain(cls, tool_class: type) -> Tool:
@@ -256,6 +266,9 @@ class Tool:
         Returns:
             A Tool reference that will be uploaded during Agent.deploy().
 
+        Raises:
+            ValueError: If the tool class has no valid string 'name' attribute or field.
+
         Example:
             >>> from langchain_core.tools import BaseTool
             >>>
@@ -267,7 +280,34 @@ class Tool:
             >>>
             >>> greeting_tool = Tool.from_langchain(GreetingTool)
         """
-        return cls(tool_class=tool_class, type=ToolType.CUSTOM)
+        # Extract name from tool_class to populate the name attribute
+        tool_name = cls._extract_tool_name(tool_class)
+        return cls(name=tool_name, tool_class=tool_class, type=ToolType.CUSTOM)
+
+    @staticmethod
+    def _extract_tool_name(tool_class: type) -> str:
+        """Extract tool name from a LangChain tool class.
+
+        Args:
+            tool_class: A LangChain BaseTool subclass.
+
+        Returns:
+            The extracted tool name.
+
+        Raises:
+            ValueError: If name cannot be extracted or is not a valid string.
+        """
+        from glaip_sdk.utils.tool_detection import get_tool_name  # noqa: PLC0415
+
+        name = get_tool_name(tool_class)
+        if name:
+            return name
+
+        # If we can't extract the name, raise an error
+        raise ValueError(
+            f"Cannot extract name from tool class {tool_class.__name__}. "
+            f"Ensure the tool class has a 'name' attribute or field with a valid string value."
+        )
 
     def get_import_path(self) -> str | None:
         """Get the import path for custom tools.
@@ -292,15 +332,8 @@ class Tool:
             return self.name
 
         if self.tool_class is not None:
-            # LangChain BaseTool - get name from model_fields
-            if hasattr(self.tool_class, "model_fields"):
-                name_field = self.tool_class.model_fields.get("name")
-                if name_field and name_field.default:
-                    return name_field.default
-
-            # Direct name attribute
-            if hasattr(self.tool_class, "name"):
-                return self.tool_class.name
+            # Reuse extraction logic for consistency
+            return self._extract_tool_name(self.tool_class)
 
         raise ValueError(f"Cannot determine name for tool: {self}")
 
@@ -354,12 +387,22 @@ class Tool:
         if not self._client:
             raise RuntimeError(_CLIENT_NOT_AVAILABLE_MSG)
 
+        # Handle both Client (has .tools) and ToolClient (direct methods)
+        # Priority: Check if client has a 'tools' attribute (Client instance)
+        # Otherwise, use client directly (ToolClient instance)
+        if hasattr(self._client, "tools") and self._client.tools is not None:
+            # Main Client instance - use the tools sub-client
+            tools_client = self._client.tools
+        else:
+            # ToolClient instance - use directly
+            tools_client = self._client
+
         # Check if file upload is requested
         if "file" in kwargs:
             file_path = kwargs.pop("file")
-            response = self._client.tools.update_via_file(self._id, file_path, **kwargs)
+            response = tools_client.update_tool_via_file(self._id, file_path, **kwargs)
         else:
-            response = self._client.tools.update(tool_id=self._id, **kwargs)
+            response = tools_client.update_tool(tool_id=self._id, **kwargs)
 
         # Update local properties from response
         if hasattr(response, "name") and response.name:
@@ -383,7 +426,17 @@ class Tool:
         if not self._client:
             raise RuntimeError(_CLIENT_NOT_AVAILABLE_MSG)
 
-        self._client.tools.delete(tool_id=self._id)
+        # Handle both Client (has .tools) and ToolClient (direct methods)
+        # Priority: Check if client has a 'tools' attribute (Client instance)
+        # Otherwise, use client directly (ToolClient instance)
+        if hasattr(self._client, "tools") and self._client.tools is not None:
+            # Main Client instance - use the tools sub-client
+            tools_client = self._client.tools
+        else:
+            # ToolClient instance - use directly
+            tools_client = self._client
+
+        tools_client.delete_tool(self._id)
         self._id = None
         self._client = None
 

glaip_sdk/utils/__init__.py

@@ -77,6 +77,7 @@ def __getattr__(name: str) -> type:
         "get_client": _client_module,
         "set_client": _client_module,
         "reset_client": _client_module,
+        "tool_detection": "glaip_sdk.utils.tool_detection",
     }
 
     if name in lazy_imports:

glaip_sdk/utils/agent_config.py

@@ -83,7 +83,9 @@ def resolve_language_model_selection(merged_data: dict[str, Any], cli_model: str
     """
     # Priority 1: CLI --model flag
     if cli_model:
-        return {"model": cli_model}, False
+        from glaip_sdk.models._validation import _validate_model  # noqa: PLC0415
+
+        return {"model": _validate_model(cli_model)}, False
 
     # Priority 2: language_model_id from import
     if merged_data.get("language_model_id"):
@@ -92,7 +94,11 @@ def resolve_language_model_selection(merged_data: dict[str, Any], cli_model: str
     # Priority 3: Legacy lm_name from agent_config
     agent_config = merged_data.get("agent_config") or {}
     if isinstance(agent_config, dict) and agent_config.get("lm_name"):
-        return {"model": agent_config["lm_name"]}, True  # Strip LM identity when extracting from agent_config
+        from glaip_sdk.models._validation import _validate_model  # noqa: PLC0415
+
+        return {
+            "model": _validate_model(agent_config["lm_name"])
+        }, True  # Strip LM identity when extracting from agent_config
 
     # No LM selection found
     return {}, False

glaip_sdk/utils/bundler.py

@@ -14,6 +14,7 @@ import inspect
 from pathlib import Path
 
 from glaip_sdk.utils.import_resolver import ImportResolver
+from glaip_sdk.utils.tool_detection import is_tool_plugin_decorator
 
 
 class ToolBundler:
@@ -50,9 +51,14 @@ class ToolBundler:
         self.tool_dir = self.tool_file.parent
         self._import_resolver = ImportResolver(self.tool_dir)
 
-    def bundle(self) -> str:
+    def bundle(self, add_tool_plugin_decorator: bool = True) -> str:
         """Bundle tool source code with inlined local imports.
 
+        Args:
+            add_tool_plugin_decorator: If True, add @tool_plugin decorator to BaseTool classes.
+                Set to False for newer servers (0.1.85+) where decorator is optional.
+                Defaults to True for backward compatibility with older servers.
+
         Returns:
             Bundled source code with all local dependencies inlined.
         """
@@ -62,6 +68,16 @@ class ToolBundler:
         tree = ast.parse(full_source)
         local_imports, external_imports = self._import_resolver.categorize_imports(tree)
 
+        # NOTE: The @tool_plugin decorator is REQUIRED by older servers (< 0.1.85) for remote execution.
+        # Newer servers (0.1.85+) make the decorator optional.
+        # The server validates uploaded tool code and will reject tools without the decorator
+        # with error: "No classes found with @tool_plugin decorator".
+        # See: docs/resources/reference/schemas/tools.md - "Plugin Requirements"
+        # TESTED: Commenting out this decorator addition causes HTTP 400 ValidationError from older servers.
+        # We try without decorator first (for new servers), then retry with decorator if validation fails.
+        if add_tool_plugin_decorator:
+            self._add_tool_plugin_decorator(tree)
+
         # Extract main code nodes (excluding imports, docstrings, glaip_sdk.Tool subclasses)
         main_code_nodes = self._extract_main_code_nodes(tree)
 
@@ -71,6 +87,13 @@ class ToolBundler:
         # Merge all external imports
         all_external_imports = external_imports + inlined_external_imports
 
+        # NOTE: The gllm_plugin.tools import is REQUIRED when decorator is added.
+        # Without this import, the decorator will cause a NameError when the server executes the code.
+        # TESTED: Commenting out this import causes NameError when server tries to use the decorator.
+        # This import is added automatically during bundling so source files can remain clean.
+        if add_tool_plugin_decorator:
+            self._ensure_tool_plugin_import(all_external_imports)
+
         # Build bundled code
         bundled_code = ["# Bundled tool with inlined local imports\n"]
         bundled_code.extend(self._import_resolver.format_external_imports(all_external_imports))
@@ -109,6 +132,103 @@ class ToolBundler:
             main_code_nodes.append(ast.unparse(node))
         return main_code_nodes
 
+    @staticmethod
+    def _add_tool_plugin_decorator(tree: ast.AST) -> None:
+        """Add @tool_plugin decorator to BaseTool classes that don't have it.
+
+        This allows tools to be clean (without decorator) for local use,
+        while the decorator is automatically added during bundling for remote execution.
+
+        Args:
+            tree: AST tree to modify in-place.
+        """
+        for node in ast.walk(tree):
+            if not isinstance(node, ast.ClassDef):
+                continue
+
+            if not ToolBundler._inherits_from_base_tool(node):
+                continue
+
+            if ToolBundler._has_tool_plugin_decorator(node):
+                continue
+
+            decorator_call = ToolBundler._create_tool_plugin_decorator()
+            node.decorator_list.insert(0, decorator_call)
+
+    @staticmethod
+    def _inherits_from_base_tool(class_node: ast.ClassDef) -> bool:
+        """Check if a class inherits from BaseTool.
+
+        Args:
+            class_node: AST ClassDef node to check.
+
+        Returns:
+            True if class inherits from BaseTool.
+        """
+        for base in class_node.bases:
+            if isinstance(base, ast.Name) and base.id == "BaseTool":
+                return True
+            if isinstance(base, ast.Attribute) and base.attr == "BaseTool":
+                # Handle nested attributes like langchain_core.tools.BaseTool
+                # Check if the value chain leads to langchain_core
+                value = base.value
+                while isinstance(value, ast.Attribute):
+                    value = value.value
+                if isinstance(value, ast.Name) and value.id == "langchain_core":
+                    return True
+        return False
+
+    @staticmethod
+    def _has_tool_plugin_decorator(class_node: ast.ClassDef) -> bool:
+        """Check if a class already has the @tool_plugin decorator.
+
+        Args:
+            class_node: AST ClassDef node to check.
+
+        Returns:
+            True if decorator already exists.
+        """
+        for decorator in class_node.decorator_list:
+            if is_tool_plugin_decorator(decorator):
+                return True
+        return False
+
+    @staticmethod
+    def _create_tool_plugin_decorator() -> ast.Call:
+        """Create a @tool_plugin decorator AST node.
+
+        Returns:
+            AST Call node representing @tool_plugin(version="1.0.0").
+        """
+        return ast.Call(
+            func=ast.Name(id="tool_plugin", ctx=ast.Load()),
+            args=[],
+            keywords=[ast.keyword(arg="version", value=ast.Constant(value="1.0.0"))],
+        )
+
+    @staticmethod
+    def _ensure_tool_plugin_import(external_imports: list) -> None:
+        """Ensure gllm_plugin.tools import is present in external imports.
+
+        Args:
+            external_imports: List of external import nodes (modified in-place).
+        """
+        # Check if import already exists
+        for import_node in external_imports:
+            if isinstance(import_node, ast.ImportFrom) and import_node.module == "gllm_plugin.tools":
+                # Check if tool_plugin is in the names
+                for alias in import_node.names:
+                    if alias.name == "tool_plugin":
+                        return  # Import already present
+
+        # Add the import
+        import_node = ast.ImportFrom(
+            module="gllm_plugin.tools",
+            names=[ast.alias(name="tool_plugin")],
+            level=0,
+        )
+        external_imports.append(import_node)
+
     @staticmethod
     def _is_sdk_tool_subclass(node: ast.ClassDef) -> bool:
         """Check if AST class definition inherits from Tool.
@@ -135,7 +255,7 @@ class ToolBundler:
         return False
 
     @classmethod
-    def bundle_from_source(cls, file_path: Path) -> tuple[str, str, str]:
+    def bundle_from_source(cls, file_path: Path, add_tool_plugin_decorator: bool = True) -> tuple[str, str, str]:
         """Extract tool info directly from source file without importing.
 
         This is used as a fallback when the tool class cannot be imported
@@ -143,6 +263,9 @@ class ToolBundler:
 
         Args:
             file_path: Path to the tool source file.
+            add_tool_plugin_decorator: If True, add @tool_plugin decorator to BaseTool classes.
+                Set to False for newer servers (0.1.85+) where decorator is optional.
+                Defaults to True for backward compatibility with older servers.
 
         Returns:
             Tuple of (name, description, bundled_source_code).
@@ -160,6 +283,12 @@ class ToolBundler:
         tool_dir = file_path.parent
         import_resolver = ImportResolver(tool_dir)
 
+        # NOTE: The @tool_plugin decorator is REQUIRED by older servers (< 0.1.85) for remote execution.
+        # Newer servers (0.1.85+) make the decorator optional.
+        # See bundle() method for detailed explanation.
+        if add_tool_plugin_decorator:
+            cls._add_tool_plugin_decorator(tree)
+
         # Find tool name and description from class definitions
         tool_name, tool_description = cls._extract_tool_metadata(tree, file_path.stem)
 
@@ -180,6 +309,13 @@ class ToolBundler:
 
         # Build bundled code
         all_external_imports = external_imports + inlined_external_imports
+
+        # NOTE: The gllm_plugin.tools import is REQUIRED when decorator is added.
+        # See bundle() method for detailed explanation.
+        # TESTED: Commenting out this import causes NameError when server tries to use the decorator.
+        if add_tool_plugin_decorator:
+            cls._ensure_tool_plugin_import(all_external_imports)
+
         bundled_code = ["# Bundled tool with inlined local imports\n"]
         bundled_code.extend(import_resolver.format_external_imports(all_external_imports))