glaip-sdk 0.0.1b5__py3-none-any.whl

glaip_sdk/client/base.py

@@ -0,0 +1,223 @@
+#!/usr/bin/env python3
+"""Base client for AIP SDK.
+
+Authors:
+    Raymond Christopher (raymond.christopher@gdplabs.id)
+"""
+
+import logging
+import os
+from typing import Any, Union
+
+import httpx
+from dotenv import load_dotenv
+
+from glaip_sdk.exceptions import (
+    AuthenticationError,
+    ConflictError,
+    ForbiddenError,
+    NotFoundError,
+    RateLimitError,
+    ServerError,
+    TimeoutError,
+    ValidationError,
+)
+
+# Set up logging without basicConfig (library best practice)
+logger = logging.getLogger("glaip_sdk")
+logger.addHandler(logging.NullHandler())
+
+client_log = logging.getLogger("glaip_sdk.client")
+client_log.addHandler(logging.NullHandler())
+
+
+class BaseClient:
+    """Base client with HTTP operations and authentication."""
+
+    def __init__(
+        self,
+        api_url: str | None = None,
+        api_key: str | None = None,
+        timeout: float = 30.0,
+        *,
+        parent_client: Union["BaseClient", None] = None,
+        load_env: bool = True,
+    ):
+        """Initialize the base client.
+
+        Args:
+            api_url: API base URL
+            api_key: API authentication key
+            timeout: Request timeout in seconds
+            parent_client: Parent client to adopt session/config from
+            load_env: Whether to load environment variables
+        """
+        self._parent_client = parent_client
+
+        if parent_client is not None:
+            # Adopt parent's session/config; DO NOT call super().__init__
+            client_log.debug("Adopting parent client configuration")
+            self.api_url = parent_client.api_url
+            self.api_key = parent_client.api_key
+            self._timeout = parent_client._timeout
+            self.http_client = parent_client.http_client
+        else:
+            # Initialize as standalone client
+            if load_env:
+                load_dotenv()
+
+            self.api_url = api_url or os.getenv("AIP_API_URL")
+            self.api_key = api_key or os.getenv("AIP_API_KEY")
+            self._timeout = timeout
+
+            if not self.api_url:
+                client_log.error("AIP_API_URL not found in environment or parameters")
+                raise ValueError("AIP_API_URL not found")
+            if not self.api_key:
+                client_log.error("AIP_API_KEY not found in environment or parameters")
+                raise ValueError("AIP_API_KEY not found")
+
+            client_log.info(f"Initializing client with API URL: {self.api_url}")
+            self.http_client = self._build_client(timeout)
+
+    def _build_client(self, timeout: float) -> httpx.Client:
+        """Build HTTP client with configuration."""
+        from glaip_sdk.config.constants import SDK_NAME, SDK_VERSION
+
+        return httpx.Client(
+            base_url=self.api_url,
+            headers={
+                "X-API-Key": self.api_key,
+                "User-Agent": f"{SDK_NAME}/{SDK_VERSION}",
+            },
+            timeout=httpx.Timeout(timeout),
+            follow_redirects=True,
+            http2=False,
+            limits=httpx.Limits(max_keepalive_connections=10, max_connections=100),
+        )
+
+    @property
+    def timeout(self) -> float:
+        """Get current timeout value."""
+        return self._timeout
+
+    @timeout.setter
+    def timeout(self, value: float):
+        """Set timeout and rebuild client."""
+        self._timeout = value
+        if (
+            hasattr(self, "http_client")
+            and self.http_client
+            and not self._parent_client
+        ):
+            self.http_client.close()
+            self.http_client = self._build_client(value)
+
+    def _request(self, method: str, endpoint: str, **kwargs) -> Any:
+        """Make HTTP request with error handling."""
+        client_log.debug(f"Making {method} request to {endpoint}")
+        try:
+            response = self.http_client.request(method, endpoint, **kwargs)
+            client_log.debug(f"Response status: {response.status_code}")
+            return self._handle_response(response)
+        except httpx.ConnectError as e:
+            client_log.warning(
+                f"Connection error on {method} {endpoint}, retrying once: {e}"
+            )
+            try:
+                response = self.http_client.request(method, endpoint, **kwargs)
+                client_log.debug(
+                    f"Retry successful, response status: {response.status_code}"
+                )
+                return self._handle_response(response)
+            except httpx.ConnectError:
+                client_log.error(f"Retry failed for {method} {endpoint}: {e}")
+                raise e
+
+    def _handle_response(self, response: httpx.Response) -> Any:
+        """Handle HTTP response with proper error handling."""
+        if response.status_code == 204:
+            return None
+
+        parsed = None
+        content_type = response.headers.get("content-type", "").lower()
+        if "json" in content_type:
+            try:
+                parsed = response.json()
+            except ValueError:
+                pass
+
+        if parsed is None:
+            if 200 <= response.status_code < 300:
+                return response.text
+            else:
+                self._raise_api_error(response.status_code, response.text)
+
+        if isinstance(parsed, dict) and "success" in parsed:
+            if parsed.get("success"):
+                return parsed.get("data", parsed)
+            else:
+                error_type = parsed.get("error", "UnknownError")
+                message = parsed.get("message", "Unknown error")
+                self._raise_api_error(
+                    response.status_code, message, error_type, payload=parsed
+                )
+
+        if 200 <= response.status_code < 300:
+            return parsed
+
+        message = parsed.get("message") if isinstance(parsed, dict) else str(parsed)
+        self._raise_api_error(response.status_code, message, payload=parsed)
+
+    def _raise_api_error(
+        self, status: int, message: str, error_type: str | None = None, *, payload=None
+    ):
+        """Raise appropriate exception with rich context."""
+        request_id = None
+        try:
+            request_id = self.http_client.headers.get("X-Request-Id")
+        except Exception:
+            pass
+
+        mapping = {
+            400: ValidationError,
+            401: AuthenticationError,
+            403: ForbiddenError,
+            404: NotFoundError,
+            408: TimeoutError,
+            409: ConflictError,
+            429: RateLimitError,
+            500: ServerError,
+            503: ServerError,
+            504: TimeoutError,
+        }
+
+        exception_class = mapping.get(status, ValidationError)
+        error_msg = f"HTTP {status}: {message}"
+        if request_id:
+            error_msg += f" (Request ID: {request_id})"
+
+        raise exception_class(
+            error_msg,
+            status_code=status,
+            error_type=error_type,
+            payload=payload,
+            request_id=request_id,
+        )
+
+    def close(self):
+        """Close the HTTP client."""
+        if (
+            hasattr(self, "http_client")
+            and self.http_client
+            and not self._parent_client
+        ):
+            self.http_client.close()
+
+    def __enter__(self):
+        """Context manager entry."""
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Context manager exit."""
+        self.close()

glaip_sdk/client/mcps.py

@@ -0,0 +1,94 @@
+#!/usr/bin/env python3
+"""MCP client for AIP SDK.
+
+Authors:
+    Raymond Christopher (raymond.christopher@gdplabs.id)
+"""
+
+import logging
+from typing import Any
+
+from glaip_sdk.client.base import BaseClient
+from glaip_sdk.models import MCP
+
+# Set up module-level logger
+logger = logging.getLogger("glaip_sdk.mcps")
+
+
+class MCPClient(BaseClient):
+    """Client for MCP operations."""
+
+    def __init__(self, *, parent_client: BaseClient | None = None, **kwargs):
+        """Initialize the MCP client.
+
+        Args:
+            parent_client: Parent client to adopt session/config from
+            **kwargs: Additional arguments for standalone initialization
+        """
+        super().__init__(parent_client=parent_client, **kwargs)
+
+    def list_mcps(self) -> list[MCP]:
+        """List all MCPs."""
+        data = self._request("GET", "/mcps/")
+        return [MCP(**mcp_data)._set_client(self) for mcp_data in (data or [])]
+
+    def get_mcp_by_id(self, mcp_id: str) -> MCP:
+        """Get MCP by ID."""
+        data = self._request("GET", f"/mcps/{mcp_id}")
+        return MCP(**data)._set_client(self)
+
+    def find_mcps(self, name: str | None = None) -> list[MCP]:
+        """Find MCPs by name."""
+        # Backend doesn't support name query parameter, so we fetch all and filter client-side
+        data = self._request("GET", "/mcps/")
+        mcps = [MCP(**mcp_data)._set_client(self) for mcp_data in (data or [])]
+
+        if name:
+            # Client-side filtering by name (case-insensitive)
+            mcps = [mcp for mcp in mcps if name.lower() in mcp.name.lower()]
+
+        return mcps
+
+    def create_mcp(
+        self,
+        name: str,
+        description: str,
+        config: dict[str, Any] | None = None,
+        **kwargs,
+    ) -> MCP:
+        """Create a new MCP."""
+        payload = {
+            "name": name,
+            "description": description,
+            **kwargs,
+        }
+
+        if config:
+            payload["config"] = config
+
+        # Create the MCP (backend returns only the ID)
+        response_data = self._request("POST", "/mcps/", json=payload)
+
+        # Extract the ID from the response
+        if isinstance(response_data, dict) and "id" in response_data:
+            mcp_id = response_data["id"]
+        else:
+            # Fallback: assume response_data is the ID directly
+            mcp_id = str(response_data)
+
+        # Fetch the full MCP details
+        return self.get_mcp_by_id(mcp_id)
+
+    def update_mcp(self, mcp_id: str, **kwargs) -> MCP:
+        """Update an existing MCP."""
+        data = self._request("PUT", f"/mcps/{mcp_id}", json=kwargs)
+        return MCP(**data)._set_client(self)
+
+    def delete_mcp(self, mcp_id: str) -> None:
+        """Delete an MCP."""
+        self._request("DELETE", f"/mcps/{mcp_id}")
+
+    def get_mcp_tools(self, mcp_id: str) -> list[dict[str, Any]]:
+        """Get tools available from an MCP."""
+        data = self._request("GET", f"/mcps/{mcp_id}/tools")
+        return data or []

glaip_sdk/client/tools.py

@@ -0,0 +1,193 @@
+#!/usr/bin/env python3
+"""Tool client for AIP SDK.
+
+Authors:
+    Raymond Christopher (raymond.christopher@gdplabs.id)
+"""
+
+import logging
+
+from glaip_sdk.client.base import BaseClient
+from glaip_sdk.models import Tool
+
+# Set up module-level logger
+logger = logging.getLogger("glaip_sdk.tools")
+
+
+class ToolClient(BaseClient):
+    """Client for tool operations."""
+
+    def __init__(self, *, parent_client: BaseClient | None = None, **kwargs):
+        """Initialize the tool client.
+
+        Args:
+            parent_client: Parent client to adopt session/config from
+            **kwargs: Additional arguments for standalone initialization
+        """
+        super().__init__(parent_client=parent_client, **kwargs)
+
+    def list_tools(self) -> list[Tool]:
+        """List all tools."""
+        data = self._request("GET", "/tools/")
+        return [Tool(**tool_data)._set_client(self) for tool_data in (data or [])]
+
+    def get_tool_by_id(self, tool_id: str) -> Tool:
+        """Get tool by ID."""
+        data = self._request("GET", f"/tools/{tool_id}")
+        return Tool(**data)._set_client(self)
+
+    def find_tools(self, name: str | None = None) -> list[Tool]:
+        """Find tools by name."""
+        # Backend doesn't support name query parameter, so we fetch all and filter client-side
+        data = self._request("GET", "/tools/")
+        tools = [Tool(**tool_data)._set_client(self) for tool_data in (data or [])]
+
+        if name:
+            # Client-side filtering by name (case-insensitive)
+            tools = [tool for tool in tools if name.lower() in tool.name.lower()]
+
+        return tools
+
+    def create_tool(
+        self,
+        name: str | None = None,
+        tool_type: str = "custom",
+        description: str | None = None,
+        tool_script: str | None = None,
+        tool_file: str | None = None,
+        file_path: str | None = None,
+        code: str | None = None,
+        framework: str = "langchain",
+        **kwargs,
+    ) -> Tool:
+        """Create a new tool.
+
+        Args:
+            name: Tool name (required if not provided via file)
+            tool_type: Tool type (defaults to "custom")
+            description: Tool description (optional)
+            tool_script: Tool script content (optional)
+            tool_file: Tool file path (optional)
+            file_path: Alternative to tool_file (for compatibility)
+            code: Alternative to tool_script (for compatibility)
+            framework: Tool framework (defaults to "langchain")
+            **kwargs: Additional tool parameters
+        """
+        # Handle compatibility parameters
+        if file_path and not tool_file:
+            tool_file = file_path
+        if code and not tool_script:
+            tool_script = code
+
+        # Auto-detect name from file if not provided
+        if not name and tool_file:
+            import os
+
+            name = os.path.splitext(os.path.basename(tool_file))[0]
+
+        if not name:
+            raise ValueError(
+                "Tool name is required (either explicitly or via file path)"
+            )
+
+        # Auto-detect description if not provided
+        if not description:
+            description = f"A {tool_type} tool"
+
+        payload = {
+            "name": name,
+            "tool_type": tool_type,
+            "description": description,
+            "framework": framework,
+            **kwargs,
+        }
+
+        if tool_script:
+            payload["tool_script"] = tool_script
+        if tool_file:
+            payload["tool_file"] = tool_file
+
+        data = self._request("POST", "/tools/", json=payload)
+        return Tool(**data)._set_client(self)
+
+    def create_tool_from_code(
+        self,
+        name: str,
+        code: str,
+        framework: str = "langchain",
+    ) -> Tool:
+        """Create a new tool plugin from code string.
+
+        This method uses the /tools/upload endpoint which properly processes
+        and registers tool plugins, unlike the regular create_tool method
+        which only creates metadata.
+
+        Args:
+            name: Name for the tool (used for temporary file naming)
+            code: Python code containing the tool plugin
+            framework: Tool framework (defaults to "langchain")
+
+        Returns:
+            Tool: The created tool object
+        """
+        import os
+        import tempfile
+
+        # Create a temporary file with the tool code
+        with tempfile.NamedTemporaryFile(
+            mode="w", suffix=".py", prefix=f"{name}_", delete=False, encoding="utf-8"
+        ) as temp_file:
+            temp_file.write(code)
+            temp_file_path = temp_file.name
+
+        try:
+            # Read the file content and upload it
+            with open(temp_file_path, encoding="utf-8") as f:
+                script_content = f.read()
+
+            # Create a file-like object for upload
+            import io
+
+            file_obj = io.BytesIO(script_content.encode("utf-8"))
+            file_obj.name = os.path.basename(temp_file_path)
+
+            # Use multipart form data for file upload
+            files = {"file": (file_obj.name, file_obj, "text/plain")}
+            data = {"framework": framework}
+
+            # Make the upload request
+            response = self._request("POST", "/tools/upload", files=files, data=data)
+            return Tool(**response)._set_client(self)
+        finally:
+            # Clean up the temporary file
+            try:
+                os.unlink(temp_file_path)
+            except OSError:
+                pass  # Ignore cleanup errors
+
+    def update_tool(self, tool_id: str, **kwargs) -> Tool:
+        """Update an existing tool."""
+        data = self._request("PUT", f"/tools/{tool_id}", json=kwargs)
+        return Tool(**data)._set_client(self)
+
+    def delete_tool(self, tool_id: str) -> None:
+        """Delete a tool."""
+        self._request("DELETE", f"/tools/{tool_id}")
+
+    def install_tool(self, tool_id: str) -> bool:
+        """Install a tool."""
+        try:
+            self._request("POST", f"/tools/{tool_id}/install")
+            return True
+        except Exception as e:
+            logger.error(f"Failed to install tool {tool_id}: {e}")
+            return False
+
+    def uninstall_tool(self, tool_id: str) -> bool:
+        """Uninstall a tool."""
+        try:
+            self._request("POST", f"/tools/{tool_id}/uninstall")
+            return True
+        except Exception as e:
+            logger.error(f"Failed to uninstall tool {tool_id}: {e}")
+            return False

glaip_sdk/client/validators.py

@@ -0,0 +1,166 @@
+"""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
+
+    @classmethod
+    def extract_tool_ids(cls, tools: list[str | Tool], client) -> 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:
+            if isinstance(tool, str):
+                # Check if it's already a UUID
+                try:
+                    UUID(tool)
+                    tool_ids.append(tool)  # Already a UUID string
+                except ValueError:
+                    # It's a name, try to find the tool and get its ID
+                    try:
+                        found_tools = client.find_tools(name=tool)
+                        if len(found_tools) == 1:
+                            tool_ids.append(str(found_tools[0].id))
+                        elif len(found_tools) > 1:
+                            raise AmbiguousResourceError(
+                                f"Multiple tools found with name '{tool}': {[t.id for t in found_tools]}"
+                            )
+                        else:
+                            raise NotFoundError(f"Tool not found: {tool}")
+                    except Exception as e:
+                        raise ValidationError(
+                            f"Failed to resolve tool name '{tool}' to ID: {e}"
+                        )
+            elif hasattr(tool, "id") and tool.id is not None:  # Tool object with ID
+                tool_ids.append(str(tool.id))
+            elif isinstance(tool, UUID):  # UUID object
+                tool_ids.append(str(tool))
+            elif (
+                hasattr(tool, "name") and tool.name is not None
+            ):  # Tool object with name but no ID
+                # Try to find the tool by name and get its ID
+                try:
+                    found_tools = client.find_tools(name=tool.name)
+                    if len(found_tools) == 1:
+                        tool_ids.append(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}")
+                except Exception as e:
+                    raise ValidationError(
+                        f"Failed to resolve tool name '{tool.name}' to ID: {e}"
+                    )
+            else:
+                raise ValidationError(
+                    f"Invalid tool reference: {tool} - must have 'id' or 'name' attribute"
+                )
+        return tool_ids
+
+    @classmethod
+    def extract_agent_ids(cls, agents: list[str | Any], client) -> 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:
+            if isinstance(agent, str):
+                # Check if it's already a UUID
+                try:
+                    UUID(agent)
+                    agent_ids.append(agent)  # Already a UUID string
+                except ValueError:
+                    # It's a name, try to find the agent and get its ID
+                    try:
+                        found_agents = client.find_agents(name=agent)
+                        if len(found_agents) == 1:
+                            agent_ids.append(str(found_agents[0].id))
+                        elif len(found_agents) > 1:
+                            raise AmbiguousResourceError(
+                                f"Multiple agents found with name '{agent}': {[a.id for a in found_agents]}"
+                            )
+                        else:
+                            raise NotFoundError(f"Agent not found: {agent}")
+                    except Exception as e:
+                        raise ValidationError(
+                            f"Failed to resolve agent name '{agent}' to ID: {e}"
+                        )
+            elif hasattr(agent, "id") and agent.id is not None:  # Agent object with ID
+                agent_ids.append(str(agent.id))
+            elif isinstance(agent, UUID):  # UUID object
+                agent_ids.append(str(agent))
+            elif (
+                hasattr(agent, "name") and agent.name is not None
+            ):  # Agent object with name but no ID
+                # Try to find the agent by name and get its ID
+                try:
+                    found_agents = client.find_agents(name=agent.name)
+                    if len(found_agents) == 1:
+                        agent_ids.append(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}")
+                except Exception as e:
+                    raise ValidationError(
+                        f"Failed to resolve agent name '{agent.name}' to ID: {e}"
+                    )
+            else:
+                raise ValidationError(
+                    f"Invalid agent reference: {agent} - must have 'id' or 'name' attribute"
+                )
+        return agent_ids
+
+    @classmethod
+    def validate_tools_exist(cls, tool_ids: list[str], client) -> None:
+        """Validate that all tool IDs exist."""
+        for tool_id in tool_ids:
+            try:
+                client.get_tool_by_id(tool_id)
+            except NotFoundError:
+                raise ValidationError(f"Tool not found: {tool_id}")
+
+    @classmethod
+    def validate_agents_exist(cls, agent_ids: list[str], client) -> None:
+        """Validate that all agent IDs exist."""
+        for agent_id in agent_ids:
+            try:
+                client.get_agent_by_id(agent_id)
+            except NotFoundError:
+                raise ValidationError(f"Agent not found: {agent_id}")