glaip-sdk 0.6.12__py3-none-any.whl → 0.6.15__py3-none-any.whl

glaip_sdk/registry/base.py

@@ -1,139 +0,0 @@
-"""Abstract base registry for caching platform objects.
-
-This module provides the BaseRegistry abstract class that serves as the
-foundation for type-specific registries (AgentRegistry, ToolRegistry, MCPRegistry).
-
-The registry pattern provides:
-    - In-memory caching to avoid redundant API calls
-    - Transparent resolution of various reference types
-    - Simple invalidation and cache management
-
-Authors:
-    Christian Trisno Sen Long Chen (christian.t.s.l.chen@gdplabs.id)
-"""
-
-from __future__ import annotations
-
-import logging
-from abc import ABC, abstractmethod
-from typing import Any, Generic, TypeVar
-
-logger = logging.getLogger(__name__)
-
-
-T = TypeVar("T")
-
-
-class BaseRegistry(ABC, Generic[T]):
-    """Abstract base registry for caching platform objects.
-
-    Provides a caching layer between local code and the AIP platform.
-    Subclasses implement type-specific resolution logic.
-
-    The registry follows a simple flow:
-        1. Check if reference is already a platform object → return as-is
-        2. Extract name from reference
-        3. Check cache → return if found
-        4. Resolve via subclass logic → cache and return
-
-    Attributes:
-        _cache: Internal cache mapping names to objects.
-
-    Example:
-        >>> class MyRegistry(BaseRegistry):
-        ...     def _extract_name(self, ref: Any) -> str:
-        ...         return ref.name if hasattr(ref, 'name') else str(ref)
-        ...
-        ...     def _resolve_and_cache(self, ref: Any, name: str) -> MyType:
-        ...         obj = fetch_from_platform(name)
-        ...         self._cache[name] = obj
-        ...         return obj
-    """
-
-    def __init__(self) -> None:
-        """Initialize the registry with an empty cache."""
-        self._cache: dict[str, T] = {}
-
-    def resolve(self, ref: Any) -> T:
-        """Resolve a reference to a platform object.
-
-        This is the main entry point for the registry. It handles:
-            - Cached references (returned from cache)
-            - New references (resolved via subclass, then cached)
-
-        Args:
-            ref: A reference to resolve. Can be a class, string name,
-                or platform object depending on the registry type.
-
-        Returns:
-            The resolved platform object.
-
-        Raises:
-            ValueError: If the reference cannot be resolved.
-        """
-        name = self._extract_name(ref)
-
-        if name in self._cache:
-            logger.debug("Cache hit: %s", name)
-            return self._cache[name]
-
-        return self._resolve_and_cache(ref, name)
-
-    def get(self, name: str) -> T | None:
-        """Get a cached object by name.
-
-        Args:
-            name: The name of the object to retrieve.
-
-        Returns:
-            The cached object, or None if not found.
-        """
-        return self._cache.get(name)
-
-    def invalidate(self, name: str) -> None:
-        """Remove an object from the cache.
-
-        Use this to force a re-fetch on the next resolve call.
-
-        Args:
-            name: The name of the object to invalidate.
-        """
-        self._cache.pop(name, None)
-        logger.debug("Invalidated cache entry: %s", name)
-
-    def clear(self) -> None:
-        """Clear all cached entries."""
-        self._cache.clear()
-        logger.debug("Cleared registry cache")
-
-    @abstractmethod
-    def _extract_name(self, ref: Any) -> str:
-        """Extract the name from a reference.
-
-        Args:
-            ref: The reference to extract a name from.
-
-        Returns:
-            The extracted name string.
-
-        Raises:
-            ValueError: If name cannot be extracted.
-        """
-
-    @abstractmethod
-    def _resolve_and_cache(self, ref: Any, name: str) -> T:
-        """Resolve the reference and cache the result.
-
-        Subclasses implement type-specific resolution logic here.
-        This method MUST cache the result in self._cache[name].
-
-        Args:
-            ref: The reference to resolve.
-            name: The extracted name for caching.
-
-        Returns:
-            The resolved platform object.
-
-        Raises:
-            ValueError: If resolution fails.
-        """

glaip_sdk/registry/mcp.py

@@ -1,253 +0,0 @@
-"""MCP registry for glaip_sdk.
-
-This module provides the MCPRegistry that caches MCPs (Model Context Protocols)
-to avoid redundant API calls when deploying agents with MCPs.
-
-Authors:
-    Christian Trisno Sen Long Chen (christian.t.s.l.chen@gdplabs.id)
-"""
-
-from __future__ import annotations
-
-import logging
-from typing import TYPE_CHECKING, Any
-
-from glaip_sdk.registry.base import BaseRegistry
-from glaip_sdk.utils.resource_refs import is_uuid
-
-if TYPE_CHECKING:
-    from glaip_sdk.mcps import MCP
-
-logger = logging.getLogger(__name__)
-
-
-class MCPRegistry(BaseRegistry["MCP"]):
-    """Registry for MCPs (Model Context Protocols).
-
-    Resolves MCP references to glaip_sdk.models.MCP objects.
-    Caches results to avoid redundant API calls.
-
-    Handles:
-        - glaip_sdk.models.MCP → return as-is (uses mcp.id)
-        - String names/IDs → lookup on platform, cache, return MCP
-
-    Attributes:
-        _cache: Internal cache mapping names to MCP objects.
-
-    Example:
-        >>> registry = get_mcp_registry()
-        >>> mcp = registry.resolve("arxiv-mcp")
-        >>> print(mcp.id)
-    """
-
-    def _extract_name(self, ref: Any) -> str:
-        """Extract MCP name from a reference.
-
-        Args:
-            ref: An MCP object, dict, or string name.
-
-        Returns:
-            The extracted MCP name.
-
-        Raises:
-            ValueError: If name cannot be extracted from the reference.
-        """
-        # String name
-        if isinstance(ref, str):
-            return ref
-
-        # Dict from API response - extract name or id
-        if isinstance(ref, dict):
-            return ref.get("name") or ref.get("id") or ""
-
-        # Already resolved MCP (glaip_sdk.models.MCP)
-        if hasattr(ref, "id") and hasattr(ref, "name") and not isinstance(ref, type):
-            return ref.name or ref.id
-
-        raise ValueError(f"Cannot extract name from: {ref}")
-
-    def _resolve_and_cache(self, ref: Any, name: str) -> MCP:
-        """Resolve MCP reference - find by name/ID or create if needed.
-
-        Args:
-            ref: The MCP reference to resolve.
-            name: The extracted MCP name.
-
-        Returns:
-            The resolved glaip_sdk.models.MCP object.
-
-        Raises:
-            ValueError: If the MCP cannot be resolved.
-        """
-        # MCP object (check if already has ID)
-        if hasattr(ref, "id") and hasattr(ref, "name") and not isinstance(ref, type):
-            if ref.id is not None:
-                # Already resolved MCP with ID - just cache and return
-                logger.debug("Caching already resolved MCP: %s", name)
-                self._cache[name] = ref
-                return ref
-
-            # MCP without ID - need to look up or create
-            return self._lookup_or_create_mcp(ref, name)
-
-        # Dict from API response - use ID directly if available
-        if isinstance(ref, dict):
-            mcp_id = ref.get("id")
-            if mcp_id:
-                from glaip_sdk.mcps.base import MCP  # noqa: PLC0415
-
-                mcp = MCP(id=mcp_id, name=ref.get("name", ""))
-                self._cache[name] = mcp
-                return mcp
-            raise ValueError(f"MCP dict missing 'id': {ref}")
-
-        # String name - look up on platform
-        if isinstance(ref, str):
-            return self._lookup_mcp_by_name(name)
-
-        raise ValueError(f"Could not resolve MCP reference: {ref}")
-
-    def _lookup_or_create_mcp(self, ref: Any, name: str) -> MCP:
-        """Look up or create an MCP from a reference.
-
-        Args:
-            ref: The MCP reference with config details.
-            name: The extracted MCP name.
-
-        Returns:
-            The resolved or created glaip_sdk.models.MCP object.
-        """
-        # Check if this MCP is lookup-only (e.g., from MCP.from_native)
-        if getattr(ref, "_lookup_only", False):
-            return self._lookup_native_mcp(name)
-
-        return self._upsert_mcp_from_ref(ref, name)
-
-    def _lookup_native_mcp(self, name: str) -> MCP:
-        """Look up a native MCP that must exist on the platform.
-
-        Used for MCP.from_native() references that should not be created.
-
-        Args:
-            name: The MCP name to look up.
-
-        Returns:
-            The found MCP.
-
-        Raises:
-            ValueError: If MCP not found or multiple found.
-        """
-        from glaip_sdk.utils.client import get_client  # noqa: PLC0415
-
-        client = get_client()
-        logger.info("Looking up native MCP: %s", name)
-
-        results = client.find_mcps(name)
-        exact_matches = [mcp for mcp in results if getattr(mcp, "name", None) == name]
-        if len(exact_matches) == 1:
-            mcp = exact_matches[0]
-            self._cache[name] = mcp
-            return mcp
-        if len(exact_matches) > 1:
-            raise ValueError(f"Multiple MCPs found with name '{name}'")
-        raise ValueError(f"MCP not found on platform: {name}")
-
-    def _upsert_mcp_from_ref(self, ref: Any, name: str) -> MCP:
-        """Create or update an MCP from a reference with config.
-
-        Args:
-            ref: The MCP reference with config details.
-            name: The extracted MCP name.
-
-        Returns:
-            The created or updated MCP.
-        """
-        from glaip_sdk.utils.client import get_client  # noqa: PLC0415
-
-        client = get_client()
-        logger.info("Upserting MCP: %s", name)
-
-        mcp = client.mcps.upsert_mcp(
-            name,
-            description=getattr(ref, "description", None),
-            config=getattr(ref, "config", None),
-            transport=getattr(ref, "transport", None),
-            metadata=getattr(ref, "metadata", None),
-            authentication=getattr(ref, "authentication", None),
-        )
-        self._cache[name] = mcp
-        return mcp
-
-    def _lookup_mcp_by_name(self, name: str) -> MCP:
-        """Look up MCP by name or ID on the platform.
-
-        Args:
-            name: The MCP name or ID to look up.
-
-        Returns:
-            The resolved glaip_sdk.models.MCP object.
-
-        Raises:
-            ValueError: If the MCP cannot be found.
-        """
-        # Lazy imports to avoid circular dependency
-        from glaip_sdk.utils.client import get_client  # noqa: PLC0415
-
-        client = get_client()
-        logger.info("Looking up MCP by name: %s", name)
-
-        # Check if it's a valid UUID
-        if is_uuid(name):
-            mcp = client.get_mcp_by_id(name)
-            if mcp:
-                self._cache[name] = mcp
-                return mcp
-        else:
-            results = client.find_mcps(name)
-            exact_matches = [mcp for mcp in results if getattr(mcp, "name", None) == name]
-            if len(exact_matches) == 1:
-                mcp = exact_matches[0]
-                self._cache[name] = mcp
-                return mcp
-            if len(exact_matches) > 1:
-                raise ValueError(f"Multiple MCPs found with name '{name}'")
-
-        raise ValueError(f"MCP not found on platform: {name}")
-
-
-class _MCPRegistrySingleton:
-    """Singleton holder for MCPRegistry to avoid global statement."""
-
-    _instance: MCPRegistry | None = None
-
-    @classmethod
-    def get_instance(cls) -> MCPRegistry:
-        """Get or create the singleton instance.
-
-        Returns:
-            The global MCPRegistry instance.
-        """
-        if cls._instance is None:
-            cls._instance = MCPRegistry()
-        return cls._instance
-
-    @classmethod
-    def reset(cls) -> None:
-        """Reset the singleton instance (for testing)."""
-        cls._instance = None
-
-
-def get_mcp_registry() -> MCPRegistry:
-    """Get the singleton MCPRegistry instance.
-
-    Returns a global MCPRegistry that caches MCPs across the session.
-
-    Returns:
-        The global MCPRegistry instance.
-
-    Example:
-        >>> from glaip_sdk.registry import get_mcp_registry
-        >>> registry = get_mcp_registry()
-        >>> mcp = registry.resolve("arxiv-mcp")
-    """
-    return _MCPRegistrySingleton.get_instance()

glaip_sdk/registry/tool.py

@@ -1,232 +0,0 @@
-"""Tool registry for glaip_sdk.
-
-This module provides the ToolRegistry that caches deployed tools
-to avoid redundant API calls when deploying agents with tools.
-
-Authors:
-    Christian Trisno Sen Long Chen (christian.t.s.l.chen@gdplabs.id)
-"""
-
-from __future__ import annotations
-
-import logging
-from typing import TYPE_CHECKING, Any
-
-from glaip_sdk.registry.base import BaseRegistry
-
-if TYPE_CHECKING:
-    from glaip_sdk.tools import Tool
-
-logger = logging.getLogger(__name__)
-
-
-class ToolRegistry(BaseRegistry["Tool"]):
-    """Registry for tools.
-
-    Resolves tool references to glaip_sdk.models.Tool objects.
-    Caches results to avoid redundant API calls and duplicate uploads.
-
-    Handles:
-        - Tool classes (LangChain BaseTool subclasses) → upload, cache, return Tool
-        - glaip_sdk.models.Tool → return as-is (uses tool.id)
-        - String names → lookup on platform, cache, return Tool
-
-    Attributes:
-        _cache: Internal cache mapping names to Tool objects.
-
-    Example:
-        >>> registry = get_tool_registry()
-        >>> tool = registry.resolve(WebSearchTool)
-        >>> print(tool.id)
-    """
-
-    def _get_name_from_model_fields(self, ref: type) -> str | None:
-        """Extract name from Pydantic model_fields if available."""
-        model_fields = getattr(ref, "model_fields", {})
-        if "name" not in model_fields:
-            return None
-        field_info = model_fields["name"]
-        default = getattr(field_info, "default", None)
-        return default if isinstance(default, str) else None
-
-    def _get_string_attr(self, obj: Any, attr: str) -> str | None:
-        """Get attribute if it's a string, otherwise None."""
-        value = getattr(obj, attr, None)
-        return value if isinstance(value, str) else None
-
-    def _extract_name(self, ref: Any) -> str:
-        """Extract tool name from a reference.
-
-        Args:
-            ref: A tool class, instance, dict, or string name.
-
-        Returns:
-            The extracted tool name.
-
-        Raises:
-            ValueError: If name cannot be extracted from the reference.
-        """
-        if isinstance(ref, str):
-            return ref
-
-        # Dict from API response - extract name or id
-        if isinstance(ref, dict):
-            return ref.get("name") or ref.get("id") or ""
-
-        # Tool instance (not a class) with name attribute
-        if not isinstance(ref, type):
-            name = self._get_string_attr(ref, "name")
-            if name:
-                return name
-
-        # Tool class - try direct attribute first, then model_fields
-        if isinstance(ref, type):
-            name = self._get_string_attr(ref, "name") or self._get_name_from_model_fields(ref)
-            if name:
-                return name
-
-        raise ValueError(f"Cannot extract name from: {ref}")
-
-    def _resolve_and_cache(self, ref: Any, name: str) -> Tool:
-        """Resolve tool reference - upload if class, find if string/native.
-
-        Args:
-            ref: The tool reference to resolve.
-            name: The extracted tool name.
-
-        Returns:
-            The resolved glaip_sdk.models.Tool object.
-
-        Raises:
-            ValueError: If the tool cannot be resolved.
-        """
-        # Lazy imports to avoid circular dependency
-        from glaip_sdk.utils.discovery import find_tool  # noqa: PLC0415
-        from glaip_sdk.utils.sync import update_or_create_tool  # noqa: PLC0415
-
-        # Already deployed tool (glaip_sdk.models.Tool with ID) - just cache and return
-        if hasattr(ref, "id") and hasattr(ref, "name") and not isinstance(ref, type):
-            if ref.id is not None:
-                logger.debug("Caching already deployed tool: %s", name)
-                self._cache[name] = ref
-                return ref
-
-            # Tool without ID (e.g., Tool.from_native()) - look up on platform
-            logger.info("Looking up native tool: %s", name)
-            tool = find_tool(name)
-            if tool:
-                self._cache[name] = tool
-                return tool
-            raise ValueError(f"Native tool not found on platform: {name}")
-
-        # Custom tool class - upload it
-        if self._is_custom_tool(ref):
-            logger.info("Uploading custom tool: %s", name)
-            tool = update_or_create_tool(ref)
-            self._cache[name] = tool
-            if tool.id:
-                self._cache[tool.id] = tool
-            return tool
-
-        # Dict from API response - use ID directly if available
-        if isinstance(ref, dict):
-            tool_id = ref.get("id")
-            if tool_id:
-                from glaip_sdk.tools.base import Tool  # noqa: PLC0415
-
-                tool = Tool(id=tool_id, name=ref.get("name", ""))
-                self._cache[name] = tool
-                return tool
-            raise ValueError(f"Tool dict missing 'id': {ref}")
-
-        # String name - look up on platform (could be native or existing tool)
-        if isinstance(ref, str):
-            logger.info("Looking up tool by name: %s", name)
-            tool = find_tool(name)
-            if tool:
-                self._cache[name] = tool
-                return tool
-            raise ValueError(f"Tool not found on platform: {name}")
-
-        raise ValueError(f"Could not resolve tool reference: {ref}")
-
-    def _is_custom_tool(self, ref: Any) -> bool:
-        """Check if reference is a custom tool class/instance.
-
-        Args:
-            ref: The reference to check.
-
-        Returns:
-            True if ref is a custom tool that needs uploading.
-        """
-        try:
-            from glaip_sdk.utils.tool_detection import (  # noqa: PLC0415
-                is_langchain_tool,
-            )
-        except ImportError:
-            return False
-
-        return is_langchain_tool(ref)
-
-    def resolve(self, ref: Any) -> Tool:
-        """Resolve a tool reference to a platform Tool object.
-
-        Overrides base resolve to handle SDK tools differently.
-
-        Args:
-            ref: The tool reference to resolve.
-
-        Returns:
-            The resolved glaip_sdk.models.Tool object.
-        """
-        # Check if it's a Tool instance (not a class)
-        if hasattr(ref, "id") and hasattr(ref, "name") and not isinstance(ref, type):
-            # If Tool has an ID, it's already deployed - return as-is
-            if ref.id is not None:
-                name = self._extract_name(ref)
-                if name not in self._cache:
-                    self._cache[name] = ref
-                return ref
-
-            # Tool without ID (e.g., from Tool.from_native()) - needs platform lookup
-            # Fall through to normal resolution
-
-        return super().resolve(ref)
-
-
-class _ToolRegistrySingleton:
-    """Singleton holder for ToolRegistry to avoid global statement."""
-
-    _instance: ToolRegistry | None = None
-
-    @classmethod
-    def get_instance(cls) -> ToolRegistry:
-        """Get or create the singleton instance.
-
-        Returns:
-            The global ToolRegistry instance.
-        """
-        if cls._instance is None:
-            cls._instance = ToolRegistry()
-        return cls._instance
-
-    @classmethod
-    def reset(cls) -> None:
-        """Reset the singleton instance (for testing)."""
-        cls._instance = None
-
-
-def get_tool_registry() -> ToolRegistry:
-    """Get the singleton ToolRegistry instance.
-
-    Returns a global ToolRegistry that caches tools across the session.
-
-    Returns:
-        The global ToolRegistry instance.
-
-    Example:
-        >>> from glaip_sdk.registry import get_tool_registry
-        >>> registry = get_tool_registry()
-        >>> tool = registry.resolve("web_search")
-    """
-    return _ToolRegistrySingleton.get_instance()

glaip_sdk/runner/__init__.py

@@ -1,59 +0,0 @@
-"""Local agent execution runners.
-
-This module provides runners for executing glaip-sdk agents locally
-without requiring the AIP backend server. The primary runner is
-LangGraphRunner which uses the aip-agents library.
-
-To use local execution, install with the [local] extra:
-    pip install "glaip-sdk[local]"
-
-Authors:
-    Christian Trisno Sen Long Chen (christian.t.s.l.chen@gdplabs.id)
-
-Example:
-    >>> from glaip_sdk.runner import get_default_runner
-    >>> from glaip_sdk.agents import Agent
-    >>>
-    >>> agent = Agent(name="my-agent", instruction="You are helpful.")
-    >>> runner = get_default_runner()
-    >>> result = runner.run(agent, "Hello!")
-"""
-
-from glaip_sdk.runner.deps import (
-    LOCAL_RUNTIME_AVAILABLE,
-    check_local_runtime_available,
-    get_local_runtime_missing_message,
-)
-from glaip_sdk.runner.langgraph import LangGraphRunner
-
-# Default runner instance
-_default_runner: LangGraphRunner | None = None
-
-
-def get_default_runner() -> LangGraphRunner:
-    """Get the default runner instance for local agent execution.
-
-    Returns:
-        The default LangGraphRunner instance.
-
-    Raises:
-        RuntimeError: If local runtime dependencies are not available.
-    """
-    global _default_runner
-
-    if not check_local_runtime_available():
-        raise RuntimeError(get_local_runtime_missing_message())
-
-    if _default_runner is None:
-        _default_runner = LangGraphRunner()
-
-    return _default_runner
-
-
-__all__ = [
-    "LOCAL_RUNTIME_AVAILABLE",
-    "LangGraphRunner",
-    "check_local_runtime_available",
-    "get_default_runner",
-    "get_local_runtime_missing_message",
-]