glaip-sdk 0.6.5b6__py3-none-any.whl → 0.7.12__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/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))
 

glaip_sdk/utils/import_resolver.py

@@ -13,6 +13,8 @@ import ast
 import importlib
 from pathlib import Path
 
+from glaip_sdk.utils.tool_detection import is_tool_plugin_decorator
+
 
 class ImportResolver:
     """Resolves and categorizes Python imports for tool bundling.
@@ -215,11 +217,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.
@@ -444,15 +484,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/rendering/renderer/base.py

@@ -8,6 +8,7 @@ from __future__ import annotations
 
 import json
 import logging
+import sys
 from datetime import datetime, timezone
 from time import monotonic
 from typing import Any
@@ -349,6 +350,9 @@ class RichStreamRenderer(TranscriptModeMixin):
             self._handle_status_event(ev)
         elif kind == "content":
             self._handle_content_event(content)
+        elif kind == "token":
+            # Token events should stream content incrementally with immediate console output
+            self._handle_token_event(content)
         elif kind == "final_response":
             self._handle_final_response_event(content, metadata)
         elif kind in {"agent_step", "agent_thinking_step"}:
@@ -368,6 +372,31 @@ class RichStreamRenderer(TranscriptModeMixin):
             self.state.append_transcript_text(content)
             self._ensure_live()
 
+    def _handle_token_event(self, content: str) -> None:
+        """Handle token streaming events - print immediately for real-time streaming."""
+        if content:
+            self.state.append_transcript_text(content)
+            # Print token content directly to stdout for immediate visibility when not verbose
+            # This bypasses Rich's Live display which has refresh rate limitations
+            if not self.verbose:
+                try:
+                    # Mark that we're streaming tokens directly to prevent Live display from starting
+                    self._streaming_tokens_directly = True
+                    # Stop Live display if active to prevent it from intercepting stdout
+                    # and causing each token to appear on a new line
+                    if self.live is not None:
+                        self._stop_live_display()
+                    # Write directly to stdout - tokens will stream on the same line
+                    # since we're bypassing Rich's console which adds newlines
+                    sys.stdout.write(content)
+                    sys.stdout.flush()
+                except Exception:
+                    # Fallback to live display if direct write fails
+                    self._ensure_live()
+            else:
+                # In verbose mode, use normal live display (debug panels handle the output)
+                self._ensure_live()
+
     def _handle_final_response_event(self, content: str, metadata: dict[str, Any]) -> None:
         """Handle final response events."""
         if content:
@@ -521,6 +550,18 @@ class RichStreamRenderer(TranscriptModeMixin):
         if getattr(self, "_transcript_mode_enabled", False):
             return
 
+        # When verbose=False and tokens were streamed directly, skip final panel
+        # The user's script will print the final result, avoiding duplication
+        if not self.verbose and getattr(self, "_streaming_tokens_directly", False):
+            # Add a newline after streaming tokens for clean separation
+            try:
+                sys.stdout.write("\n")
+                sys.stdout.flush()
+            except Exception:
+                pass
+            self.state.printed_final_output = True
+            return
+
         if self.verbose:
             panel = build_final_panel(
                 self.state,
@@ -597,6 +638,19 @@ class RichStreamRenderer(TranscriptModeMixin):
 
     def _finalize_display(self) -> None:
         """Finalize live display and render final output."""
+        # When verbose=False and tokens were streamed directly, skip live display updates
+        # to avoid showing duplicate final result
+        if not self.verbose and getattr(self, "_streaming_tokens_directly", False):
+            # Just add a newline after streaming tokens for clean separation
+            try:
+                sys.stdout.write("\n")
+                sys.stdout.flush()
+            except Exception:
+                pass
+            self._stop_live_display()
+            self.state.printed_final_output = True
+            return
+
         # Final refresh
         self._ensure_live()
 
@@ -629,6 +683,10 @@ class RichStreamRenderer(TranscriptModeMixin):
         """Ensure live display is updated."""
         if getattr(self, "_transcript_mode_enabled", False):
             return
+        # When verbose=False, don't start Live display if we're streaming tokens directly
+        # This prevents Live from intercepting stdout and causing tokens to appear on separate lines
+        if not self.verbose and getattr(self, "_streaming_tokens_directly", False):
+            return
         if not self._ensure_live_stack():
             return
 

glaip_sdk/utils/runtime_config.py

@@ -315,7 +315,7 @@ def normalize_runtime_config_keys(
 
 
 def _get_name_from_class(cls: type) -> str:
-    """Extract name from a class, handling Pydantic models.
+    """Extract name from a class, handling Pydantic models and @property descriptors.
 
     Args:
         cls: The class to extract name from.
@@ -323,9 +323,10 @@ def _get_name_from_class(cls: type) -> str:
     Returns:
         The resolved name string.
     """
-    # Try class-level name attribute first
+    # Try class-level name attribute first, but guard against @property descriptors
+    # When a class has @property name, getattr returns the property object, not a string
     class_name = getattr(cls, "name", None)
-    if class_name:
+    if isinstance(class_name, str) and class_name:
         return class_name
 
     # For Pydantic models, check model_fields for default value
@@ -355,24 +356,26 @@ def get_name_from_key(key: object) -> str | None:
     Raises:
         ValueError: If the key cannot be resolved to a valid name.
     """
-    # Instance with name attribute
-    if hasattr(key, "name"):
-        name = getattr(key, "name", None)
-        if name:
-            return name
-        raise ValueError(f"Unable to resolve config key: {key!r}")
-
-    # Class type (not instance)
+    # Class type (not instance) - must check BEFORE hasattr("name")
+    # because classes with @property name will have hasattr return True
+    # but getattr returns the property descriptor, not a string
     if isinstance(key, type):
         return _get_name_from_class(key)
 
-    # String key
+    # String key - check early to avoid attribute access
     if isinstance(key, str):
         if is_uuid(key):
             logger.warning("UUID '%s' not supported in local mode, skipping", key)
             return None
         return key
 
+    # Instance with name attribute
+    if hasattr(key, "name"):
+        name = getattr(key, "name", None)
+        # Guard against @property that returns non-string (e.g., descriptor)
+        if isinstance(name, str) and name:
+            return name
+
     raise ValueError(f"Unable to resolve config key: {key!r}")
 
 

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: