glaip-sdk 0.6.15b2__py3-none-any.whl → 0.6.16__py3-none-any.whl

glaip_sdk/client/validators.py

@@ -0,0 +1,198 @@
+"""Validation utilities for AIP SDK.
+
+Authors:
+    Raymond Christopher (raymond.christopher@gdplabs.id)
+"""
+
+from typing import Any
+from uuid import UUID
+
+from glaip_sdk.exceptions import AmbiguousResourceError, NotFoundError, ValidationError
+from glaip_sdk.models import Tool
+
+
+class ResourceValidator:
+    """Validates and resolves resource references."""
+
+    RESERVED_NAMES = {
+        "research-agent",
+        "github-agent",
+        "aws-pricing-filter-generator-agent",
+    }
+
+    @classmethod
+    def is_reserved_name(cls, name: str) -> bool:
+        """Check if a name is reserved."""
+        return name in cls.RESERVED_NAMES
+
+    def _is_uuid_string(self, value: str) -> bool:
+        """Check if a string is a valid UUID."""
+        try:
+            UUID(value)
+            return True
+        except ValueError:
+            return False
+
+    def _resolve_tool_by_name(self, tool_name: str, client: Any) -> str:
+        """Resolve tool name to ID."""
+        found_tools = client.find_tools(name=tool_name)
+        if len(found_tools) == 1:
+            return str(found_tools[0].id)
+        elif len(found_tools) > 1:
+            raise AmbiguousResourceError(f"Multiple tools found with name '{tool_name}': {[t.id for t in found_tools]}")
+        else:
+            raise NotFoundError(f"Tool not found: {tool_name}")
+
+    def _resolve_tool_by_name_attribute(self, tool: Tool, client: Any) -> str:
+        """Resolve tool by name attribute."""
+        found_tools = client.find_tools(name=tool.name)
+        if len(found_tools) == 1:
+            return str(found_tools[0].id)
+        elif len(found_tools) > 1:
+            raise AmbiguousResourceError(f"Multiple tools found with name '{tool.name}': {[t.id for t in found_tools]}")
+        else:
+            raise NotFoundError(f"Tool not found: {tool.name}")
+
+    def _process_tool_string(self, tool: str, client: Any) -> str:
+        """Process a string tool reference."""
+        if self._is_uuid_string(tool):
+            return tool  # Already a UUID string
+        else:
+            return self._resolve_tool_by_name(tool, client)
+
+    def _process_tool_object(self, tool: Tool, client: Any) -> str:
+        """Process a Tool object reference."""
+        if hasattr(tool, "id") and tool.id is not None:
+            return str(tool.id)
+        elif isinstance(tool, UUID):
+            return str(tool)
+        elif hasattr(tool, "name") and tool.name is not None:
+            return self._resolve_tool_by_name_attribute(tool, client)
+        else:
+            raise ValidationError(f"Invalid tool reference: {tool} - must have 'id' or 'name' attribute")
+
+    def _process_single_tool(self, tool: str | Tool, client: Any) -> str:
+        """Process a single tool reference and return its ID."""
+        if isinstance(tool, str):
+            return self._process_tool_string(tool, client)
+        else:
+            return self._process_tool_object(tool, client)
+
+    @classmethod
+    def extract_tool_ids(cls, tools: list[str | Tool], client: Any) -> list[str]:
+        """Extract tool IDs from a list of tool names, IDs, or Tool objects.
+
+        For agent creation, the backend expects tool IDs (UUIDs).
+        This method handles:
+        - Tool objects (extracts their ID)
+        - UUID strings (passes through)
+        - Tool names (finds tool and extracts ID)
+        """
+        tool_ids = []
+        for tool in tools:
+            try:
+                tool_id = cls()._process_single_tool(tool, client)
+                tool_ids.append(tool_id)
+            except (AmbiguousResourceError, NotFoundError) as err:
+                # Determine the tool name for the error message
+                tool_name = tool if isinstance(tool, str) else getattr(tool, "name", str(tool))
+                raise ValidationError(f"Failed to resolve tool name '{tool_name}' to ID: {err}") from err
+            except Exception as err:
+                # For other exceptions, wrap them appropriately
+                tool_name = tool if isinstance(tool, str) else getattr(tool, "name", str(tool))
+                raise ValidationError(f"Failed to resolve tool name '{tool_name}' to ID: {err}") from err
+
+        return tool_ids
+
+    def _resolve_agent_by_name(self, agent_name: str, client: Any) -> str:
+        """Resolve agent name to ID."""
+        found_agents = client.find_agents(name=agent_name)
+        if len(found_agents) == 1:
+            return str(found_agents[0].id)
+        elif len(found_agents) > 1:
+            raise AmbiguousResourceError(
+                f"Multiple agents found with name '{agent_name}': {[a.id for a in found_agents]}"
+            )
+        else:
+            raise NotFoundError(f"Agent not found: {agent_name}")
+
+    def _resolve_agent_by_name_attribute(self, agent: Any, client: Any) -> str:
+        """Resolve agent by name attribute."""
+        found_agents = client.find_agents(name=agent.name)
+        if len(found_agents) == 1:
+            return str(found_agents[0].id)
+        elif len(found_agents) > 1:
+            raise AmbiguousResourceError(
+                f"Multiple agents found with name '{agent.name}': {[a.id for a in found_agents]}"
+            )
+        else:
+            raise NotFoundError(f"Agent not found: {agent.name}")
+
+    def _process_agent_string(self, agent: str, client: Any) -> str:
+        """Process a string agent reference."""
+        if self._is_uuid_string(agent):
+            return agent  # Already a UUID string
+        else:
+            return self._resolve_agent_by_name(agent, client)
+
+    def _process_agent_object(self, agent: Any, client: Any) -> str:
+        """Process an Agent object reference."""
+        if hasattr(agent, "id") and agent.id is not None:
+            return str(agent.id)
+        elif isinstance(agent, UUID):
+            return str(agent)
+        elif hasattr(agent, "name") and agent.name is not None:
+            return self._resolve_agent_by_name_attribute(agent, client)
+        else:
+            raise ValidationError(f"Invalid agent reference: {agent} - must have 'id' or 'name' attribute")
+
+    def _process_single_agent(self, agent: str | Any, client: Any) -> str:
+        """Process a single agent reference and return its ID."""
+        if isinstance(agent, str):
+            return self._process_agent_string(agent, client)
+        else:
+            return self._process_agent_object(agent, client)
+
+    @classmethod
+    def extract_agent_ids(cls, agents: list[str | Any], client: Any) -> list[str]:
+        """Extract agent IDs from a list of agent names, IDs, or agent objects.
+
+        For agent creation, the backend expects agent IDs (UUIDs).
+        This method handles:
+        - Agent objects (extracts their ID)
+        - UUID strings (passes through)
+        - Agent names (finds agent and extracts ID)
+        """
+        agent_ids = []
+        for agent in agents:
+            try:
+                agent_id = cls()._process_single_agent(agent, client)
+                agent_ids.append(agent_id)
+            except (AmbiguousResourceError, NotFoundError) as err:
+                # Determine the agent name for the error message
+                agent_name = agent if isinstance(agent, str) else getattr(agent, "name", str(agent))
+                raise ValidationError(f"Failed to resolve agent name '{agent_name}' to ID: {err}") from err
+            except Exception as err:
+                # For other exceptions, wrap them appropriately
+                agent_name = agent if isinstance(agent, str) else getattr(agent, "name", str(agent))
+                raise ValidationError(f"Failed to resolve agent name '{agent_name}' to ID: {err}") from err
+
+        return agent_ids
+
+    @classmethod
+    def validate_tools_exist(cls, tool_ids: list[str], client: Any) -> None:
+        """Validate that all tool IDs exist."""
+        for tool_id in tool_ids:
+            try:
+                client.get_tool_by_id(tool_id)
+            except NotFoundError as err:
+                raise ValidationError(f"Tool not found: {tool_id}") from err
+
+    @classmethod
+    def validate_agents_exist(cls, agent_ids: list[str], client: Any) -> None:
+        """Validate that all agent IDs exist."""
+        for agent_id in agent_ids:
+            try:
+                client.get_agent_by_id(agent_id)
+            except NotFoundError as err:
+                raise ValidationError(f"Agent not found: {agent_id}") from err

glaip_sdk/config/constants.py

@@ -0,0 +1,52 @@
+"""Configuration constants for the AIP SDK.
+
+Authors:
+    Raymond Christopher (raymond.christopher@gdplabs.id)
+"""
+
+# Default language model configuration
+DEFAULT_MODEL = "gpt-5-nano"
+DEFAULT_AGENT_RUN_TIMEOUT = 300
+
+# User agent and version
+SDK_NAME = "glaip-sdk"
+
+# Reserved names that cannot be used for agents/tools
+RESERVED_NAMES = {
+    "system",
+    "admin",
+    "root",
+    "test",
+    "example",
+    "demo",
+    "sample",
+}
+
+# Agent creation/update constants
+DEFAULT_AGENT_TYPE = "config"
+DEFAULT_AGENT_FRAMEWORK = "langchain"
+DEFAULT_AGENT_VERSION = "1.0"
+DEFAULT_AGENT_PROVIDER = "openai"
+
+# Tool creation/update constants
+DEFAULT_TOOL_TYPE = "custom"
+DEFAULT_TOOL_FRAMEWORK = "langchain"
+DEFAULT_TOOL_VERSION = "1.0"
+
+# MCP creation/update constants
+DEFAULT_MCP_TYPE = "server"
+DEFAULT_MCP_TRANSPORT = "stdio"
+
+# Default error messages
+DEFAULT_ERROR_MESSAGE = "Unknown error"
+
+# Agent configuration fields used for CLI args and payload building
+AGENT_CONFIG_FIELDS = (
+    "name",
+    "instruction",
+    "model",
+    "tools",
+    "agents",
+    "mcps",
+    "timeout",
+)

glaip_sdk/mcps/__init__.py

@@ -0,0 +1,21 @@
+"""MCP (Model Context Protocol) package for GL AIP platform.
+
+This package provides the MCP class and MCPRegistry for managing
+Model Context Protocol configurations on the GL AIP platform.
+
+Example:
+    >>> from glaip_sdk.mcps import MCP, get_mcp_registry
+    >>> mcp = MCP.from_native("arxiv-search")
+"""
+
+from __future__ import annotations
+
+from glaip_sdk.mcps.base import MCP, MCPConfigValue
+from glaip_sdk.registry.mcp import MCPRegistry, get_mcp_registry
+
+__all__ = [
+    "MCP",
+    "MCPConfigValue",
+    "MCPRegistry",
+    "get_mcp_registry",
+]

glaip_sdk/mcps/base.py

@@ -0,0 +1,345 @@
+"""MCP (Model Context Protocol) helper for glaip_sdk.
+
+Provides a simple, migration-ready way to declare and resolve MCPs with
+in-memory caching and create-on-missing functionality.
+
+The MCP class also supports runtime operations (update, delete, get_tools)
+when retrieved from the API via client.mcps.get().
+
+Authors:
+    Christian Trisno Sen Long Chen (christian.t.s.l.chen@gdplabs.id)
+
+Example - Lazy Reference:
+    >>> from glaip_sdk.mcps import MCP
+    >>>
+    >>> # Create from known ID
+    >>> mcp = MCP.from_id("mcp_abc123")
+    >>>
+    >>> # Create lookup-only by name (error if not found)
+    >>> mcp = MCP.from_native("arxiv-search")
+    >>>
+    >>> # Create for lookup/creation by name (create if missing)
+    >>> mcp = MCP(name="my-filesystem-mcp", transport="sse", config={"url": "..."})
+
+Example - Runtime Operations:
+    >>> from glaip_sdk import Glaip
+    >>>
+    >>> client = Glaip()
+    >>> mcp = client.mcps.get("mcp-123")
+    >>> tools = mcp.get_tools()  # Get tools from MCP
+    >>> mcp.update(description="Updated description")
+    >>> mcp.delete()
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from glaip_sdk.models import MCPResponse
+
+# Type alias for MCP configuration values
+MCPConfigValue = str | int | bool | list[str] | dict[str, str]
+
+_MCP_NOT_DEPLOYED_MSG = "MCP not available on platform. No ID set."
+_CLIENT_NOT_AVAILABLE_MSG = "Client not available. Use client.mcps.get() to get a client-connected MCP."
+
+
+class MCP:
+    """MCP reference helper for declaring MCPs in Agent definitions.
+
+    Supports both lazy references and runtime operations:
+    - Lazy reference: Created via from_native() or from_id()
+    - Runtime: Created via from_response() or client.mcps.get()
+
+    Attributes:
+        name: Human-readable MCP name (used for lookup/creation).
+        id: Backend MCP ID (used for direct fetch if known).
+        transport: Transport type (e.g., "sse", "stdio", "websocket").
+        config: Transport configuration dict (URLs, args, env vars).
+        description: Optional description for the MCP.
+        metadata: Optional additional metadata dict.
+        authentication: Authentication configuration.
+
+    Example - Lazy Reference:
+        >>> # Create from known ID
+        >>> mcp = MCP.from_id("mcp_abc123")
+        >>>
+        >>> # Create lookup-only by name (error if not found)
+        >>> mcp = MCP.from_native("arxiv-search")
+        >>>
+        >>> # Create for lookup/creation by name (create if missing)
+        >>> mcp = MCP(name="my-filesystem-mcp", transport="sse", config={"url": "..."})
+
+    Example - Runtime Operations:
+        >>> mcp = client.mcps.get("mcp-123")
+        >>> mcp.update(description="New description")
+        >>> mcp.delete()
+    """
+
+    def __init__(
+        self,
+        name: str | None = None,
+        *,
+        id: str | None = None,  # noqa: A002 - Allow shadowing builtin for API compat
+        transport: str | None = None,
+        config: dict[str, MCPConfigValue] | None = None,
+        description: str | None = None,
+        metadata: dict[str, Any] | None = None,
+        authentication: dict[str, Any] | None = None,
+        _lookup_only: bool = False,
+        _client: Any = None,
+    ) -> None:
+        """Initialize an MCP.
+
+        Args:
+            name: Human-readable MCP name.
+            id: Backend MCP ID.
+            transport: Transport type (e.g., "sse", "stdio").
+            config: Transport configuration dict.
+            description: Optional description.
+            metadata: Optional metadata dict.
+            authentication: Authentication configuration.
+            _lookup_only: If True, don't create if not found.
+            _client: Internal client reference.
+
+        Raises:
+            ValueError: If neither name nor id is provided.
+        """
+        if not name and not id:
+            raise ValueError("At least one of 'name' or 'id' must be provided")
+
+        self.name = name
+        self._id = id
+        self.transport = transport
+        self.config = config
+        self.description = description
+        self.metadata = metadata
+        self.authentication = authentication
+        self._lookup_only = _lookup_only
+        self._client = _client
+
+    @property
+    def id(self) -> str | None:  # noqa: A003 - Allow shadowing builtin for API compat
+        """MCP ID on the platform."""
+        return self._id
+
+    @id.setter
+    def id(self, value: str | None) -> None:  # noqa: A003
+        """Set the MCP ID."""
+        self._id = value
+
+    def __repr__(self) -> str:
+        """Return string representation."""
+        if self._id:
+            return f"MCP(id={self._id!r}, name={self.name!r})"
+        if self._lookup_only:
+            return f"MCP.from_native({self.name!r})"
+        return f"MCP(name={self.name!r})"
+
+    def __eq__(self, other: object) -> bool:
+        """Check equality based on id if available, else name."""
+        if not isinstance(other, MCP):
+            return NotImplemented
+        if self._id and other._id:
+            return self._id == other._id
+        return self.name == other.name
+
+    def __hash__(self) -> int:
+        """Hash based on id if available, else name."""
+        if self._id:
+            return hash(self._id)
+        return hash(self.name)
+
+    def model_dump(self, *, exclude_none: bool = False) -> dict[str, Any]:
+        """Return a dict representation of the MCP.
+
+        Provides Pydantic-style serialization for backward compatibility.
+
+        Args:
+            exclude_none: If True, exclude None values from the output.
+
+        Returns:
+            Dictionary containing MCP attributes.
+        """
+        data = {
+            "id": self._id,
+            "name": self.name,
+            "transport": self.transport,
+            "config": self.config,
+            "description": self.description,
+            "metadata": self.metadata,
+            "authentication": self.authentication,
+        }
+        if exclude_none:
+            return {k: v for k, v in data.items() if v is not None}
+        return data
+
+    @classmethod
+    def from_native(cls, name: str) -> MCP:
+        """Create a lookup-only MCP reference by name.
+
+        Use this when referencing an MCP that already exists on the platform.
+        Resolution will NOT create the MCP if not found - it will raise an error.
+
+        Args:
+            name: The name of the existing MCP.
+
+        Returns:
+            MCP instance configured for lookup-only resolution.
+
+        Raises:
+            ValueError: If name is empty.
+
+        Example:
+            >>> mcp = MCP.from_native("arxiv-search")
+            >>> # Registry will find by name, error if not found or ambiguous
+        """
+        if not name:
+            raise ValueError("Name cannot be empty")
+        return cls(name=name, _lookup_only=True)
+
+    @classmethod
+    def from_id(cls, mcp_id: str) -> MCP:
+        """Create an MCP helper for lookup-only by ID.
+
+        This creates a minimal MCP reference that will be resolved
+        from the backend using the ID. Use this when you know the
+        backend MCP ID but don't have the full configuration.
+
+        Args:
+            mcp_id: The backend MCP ID.
+
+        Returns:
+            An MCP instance with only the ID set, marked for lookup-only.
+
+        Raises:
+            ValueError: If mcp_id is empty.
+
+        Example:
+            >>> mcp = MCP.from_id("550e8400-e29b-41d4-a716-446655440000")
+            >>> # Registry will fetch directly by ID
+        """
+        if not mcp_id:
+            raise ValueError("ID cannot be empty")
+        return cls(id=mcp_id, _lookup_only=True)
+
+    # ─────────────────────────────────────────────────────────────────
+    # Runtime Methods (require client connection)
+    # ─────────────────────────────────────────────────────────────────
+
+    def _set_client(self, client: Any) -> MCP:
+        """Set the client reference for this MCP.
+
+        Args:
+            client: The Glaip client instance.
+
+        Returns:
+            Self for method chaining.
+        """
+        self._client = client
+        return self
+
+    def get_tools(self) -> list[dict[str, Any]]:
+        """Get tools available from this MCP.
+
+        Returns:
+            List of tool definitions from the MCP.
+
+        Raises:
+            ValueError: If the MCP has no ID.
+            RuntimeError: If client is not available.
+        """
+        if not self._id:
+            raise ValueError(_MCP_NOT_DEPLOYED_MSG)
+        if not self._client:
+            raise RuntimeError(_CLIENT_NOT_AVAILABLE_MSG)
+
+        # Delegate to the client's MCP tools endpoint
+        return self._client.mcps.get_tools(mcp_id=self._id)
+
+    def update(self, **kwargs: Any) -> MCP:
+        """Update the MCP with new configuration.
+
+        Args:
+            **kwargs: MCP properties to update (name, description, config, etc.).
+
+        Returns:
+            Self with updated properties.
+
+        Raises:
+            ValueError: If the MCP has no ID.
+            RuntimeError: If client is not available.
+        """
+        if not self._id:
+            raise ValueError(_MCP_NOT_DEPLOYED_MSG)
+        if not self._client:
+            raise RuntimeError(_CLIENT_NOT_AVAILABLE_MSG)
+
+        response = self._client.mcps.update(mcp_id=self._id, **kwargs)
+
+        # Update local properties from response
+        if hasattr(response, "name") and response.name:
+            self.name = response.name
+        if hasattr(response, "description"):
+            self.description = response.description
+        if hasattr(response, "config"):
+            self.config = response.config
+        if hasattr(response, "transport"):
+            self.transport = response.transport
+
+        return self
+
+    def delete(self) -> None:
+        """Delete the MCP from the platform.
+
+        Raises:
+            ValueError: If the MCP has no ID.
+            RuntimeError: If client is not available.
+        """
+        if not self._id:
+            raise ValueError(_MCP_NOT_DEPLOYED_MSG)
+        if not self._client:
+            raise RuntimeError(_CLIENT_NOT_AVAILABLE_MSG)
+
+        self._client.mcps.delete(mcp_id=self._id)
+        self._id = None
+        self._client = None
+
+    @classmethod
+    def from_response(
+        cls,
+        response: MCPResponse,
+        client: Any = None,
+    ) -> MCP:
+        """Create an MCP instance from an API response.
+
+        This allows you to work with MCPs retrieved from the API
+        as full MCP instances with all methods available.
+
+        Args:
+            response: The MCPResponse from an API call.
+            client: The Glaip client instance for API operations.
+
+        Returns:
+            An MCP instance initialized from the response.
+
+        Example:
+            >>> response = client.mcps.get("mcp-123")
+            >>> mcp = MCP.from_response(response, client)
+            >>> tools = mcp.get_tools()
+        """
+        mcp = cls(
+            name=response.name,
+            id=response.id,
+            description=getattr(response, "description", None),
+            transport=getattr(response, "transport", None),
+            config=getattr(response, "config", None),
+            metadata=getattr(response, "metadata", None),
+            authentication=getattr(response, "authentication", None),
+        )
+
+        if client:
+            mcp._set_client(client)
+
+        return mcp