glaip-sdk 0.0.3__py3-none-any.whl → 0.0.5__py3-none-any.whl

glaip_sdk/client/base.py

@@ -12,6 +12,7 @@ from typing import Any, Union
 import httpx
 from dotenv import load_dotenv
 
+import glaip_sdk
 from glaip_sdk.config.constants import SDK_NAME, SDK_VERSION
 from glaip_sdk.exceptions import (
     AuthenticationError,
@@ -54,6 +55,7 @@ class BaseClient:
             load_env: Whether to load environment variables
         """
         self._parent_client = parent_client
+        self._session_scoped = False  # Mark as not session-scoped by default
 
         if parent_client is not None:
             # Adopt parent's session/config; DO NOT call super().__init__
@@ -64,8 +66,11 @@ class BaseClient:
             self.http_client = parent_client.http_client
         else:
             # Initialize as standalone client
-            if load_env:
-                load_dotenv()
+            if load_env and not (api_url and api_key):
+                # Only load .env file if explicit credentials not provided
+                package_dir = os.path.dirname(glaip_sdk.__file__)
+                env_file = os.path.join(package_dir, ".env")
+                load_dotenv(env_file)
 
             self.api_url = api_url or os.getenv("AIP_API_URL")
             self.api_key = api_key or os.getenv("AIP_API_KEY")
@@ -105,6 +110,37 @@ class BaseClient:
             limits=httpx.Limits(max_keepalive_connections=10, max_connections=100),
         )
 
+    def _build_async_client(self, timeout: float) -> dict[str, Any]:
+        """Build async client configuration (returns dict of kwargs for httpx.AsyncClient).
+
+        Args:
+            timeout: Request timeout in seconds
+
+        Returns:
+            Dictionary of kwargs for httpx.AsyncClient
+        """
+        # For streaming operations, we need more generous read timeouts
+        # while keeping reasonable connect timeouts
+        timeout_config = httpx.Timeout(
+            timeout=timeout,  # Total timeout
+            connect=min(30.0, timeout),  # Connect timeout (max 30s)
+            read=timeout,  # Read timeout (same as total for streaming)
+            write=min(30.0, timeout),  # Write timeout (max 30s)
+            pool=timeout,  # Pool timeout (same as total)
+        )
+
+        return {
+            "base_url": self.api_url,
+            "headers": {
+                "X-API-Key": self.api_key,
+                "User-Agent": f"{SDK_NAME}/{SDK_VERSION}",
+            },
+            "timeout": timeout_config,
+            "follow_redirects": True,
+            "http2": False,
+            "limits": httpx.Limits(max_keepalive_connections=10, max_connections=100),
+        }
+
     @property
     def timeout(self) -> float:
         """Get current timeout value."""
@@ -117,6 +153,7 @@ class BaseClient:
         if (
             hasattr(self, "http_client")
             and self.http_client
+            and not self._session_scoped
             and not self._parent_client
         ):
             self.http_client.close()
@@ -173,8 +210,30 @@ class BaseClient:
         get_endpoint = get_endpoint_fmt.format(id=resource_id)
         return self._request("GET", get_endpoint)
 
+    def _ensure_client_alive(self):
+        """Ensure HTTP client is alive, recreate if needed."""
+        if not hasattr(self, "http_client") or self.http_client is None:
+            if not self._parent_client:
+                self.http_client = self._build_client(self._timeout)
+            return
+
+        # Check if client is closed by attempting a simple operation
+        try:
+            # Try to access a property that would fail if closed
+            _ = self.http_client.headers
+        except (RuntimeError, AttributeError) as e:
+            if "closed" in str(e).lower() or "NoneType" in str(e):
+                client_log.debug("HTTP client was closed, recreating")
+                if not self._parent_client:
+                    self.http_client = self._build_client(self._timeout)
+            else:
+                raise
+
     def _request(self, method: str, endpoint: str, **kwargs) -> Any:
         """Make HTTP request with error handling."""
+        # Ensure client is alive before making request
+        self._ensure_client_alive()
+
         client_log.debug(f"Making {method} request to {endpoint}")
         try:
             response = self.http_client.request(method, endpoint, **kwargs)
@@ -270,6 +329,7 @@ class BaseClient:
         if (
             hasattr(self, "http_client")
             and self.http_client
+            and not self._session_scoped
             and not self._parent_client
         ):
             self.http_client.close()
@@ -278,6 +338,8 @@ class BaseClient:
         """Context manager entry."""
         return self
 
-    def __exit__(self, exc_type, exc_val, exc_tb):
+    def __exit__(self, _exc_type, _exc_val, _exc_tb):
         """Context manager exit."""
-        self.close()
+        # Only close if this is not session-scoped
+        if not self._session_scoped:
+            self.close()

glaip_sdk/client/main.py

@@ -0,0 +1,226 @@
+#!/usr/bin/env python3
+"""Main client for AIP SDK.
+
+Authors:
+    Raymond Christopher (raymond.christopher@gdplabs.id)
+"""
+
+from typing import Any
+
+from glaip_sdk.client.agents import AgentClient
+from glaip_sdk.client.base import BaseClient
+from glaip_sdk.client.mcps import MCPClient
+from glaip_sdk.client.tools import ToolClient
+from glaip_sdk.models import MCP, Agent, Tool
+
+
+class Client(BaseClient):
+    """Main client that composes all specialized clients and shares one HTTP session."""
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        # Share the single httpx.Client + config with sub-clients
+        shared_config = {
+            "parent_client": self,
+            "api_url": self.api_url,
+            "api_key": self.api_key,
+            "timeout": self._timeout,
+        }
+        self.agents = AgentClient(**shared_config)
+        self.tools = ToolClient(**shared_config)
+        self.mcps = MCPClient(**shared_config)
+
+    # ---- Core API Methods (Public Interface) ----
+
+    # Agents
+    def create_agent(self, **kwargs) -> Agent:
+        """Create a new agent."""
+        return self.agents.create_agent(**kwargs)
+
+    def list_agents(
+        self,
+        agent_type: str | None = None,
+        framework: str | None = None,
+        name: str | None = None,
+        version: str | None = None,
+        sync_langflow_agents: bool = False,
+    ) -> list[Agent]:
+        """List agents with optional filtering.
+
+        Args:
+            agent_type: Filter by agent type (config, code, a2a)
+            framework: Filter by framework (langchain, langgraph, google_adk)
+            name: Filter by partial name match (case-insensitive)
+            version: Filter by exact version match
+            sync_langflow_agents: Sync with LangFlow server before listing (only applies when agent_type=langflow)
+
+        Returns:
+            List of agents matching the filters
+        """
+        return self.agents.list_agents(
+            agent_type=agent_type,
+            framework=framework,
+            name=name,
+            version=version,
+            sync_langflow_agents=sync_langflow_agents,
+        )
+
+    def get_agent_by_id(self, agent_id: str) -> Agent | None:
+        """Get agent by ID."""
+        return self.agents.get_agent_by_id(agent_id)
+
+    def get_agent(self, agent_id: str) -> Agent | None:
+        """Get agent by ID (alias for get_agent_by_id)."""
+        return self.get_agent_by_id(agent_id)
+
+    def find_agents(self, name: str | None = None) -> list[Agent]:
+        """Find agents by name."""
+        return self.agents.find_agents(name)
+
+    def update_agent(self, agent_id: str, **kwargs) -> Agent:
+        """Update an existing agent."""
+        return self.agents.update_agent(agent_id, **kwargs)
+
+    def delete_agent(self, agent_id: str) -> bool:
+        """Delete an agent."""
+        return self.agents.delete_agent(agent_id)
+
+    def run_agent(self, agent_id: str, message: str, **kwargs) -> str:
+        """Run an agent with a message."""
+        return self.agents.run_agent(agent_id, message, **kwargs)
+
+    def sync_langflow_agents(
+        self,
+        base_url: str | None = None,
+        api_key: str | None = None,
+    ) -> dict[str, Any]:
+        """Sync LangFlow agents by fetching flows from the LangFlow server.
+
+        This method synchronizes agents with LangFlow flows. It fetches all flows
+        from the configured LangFlow server and creates/updates corresponding agents.
+
+        Args:
+            base_url: Custom LangFlow server base URL. If not provided, uses LANGFLOW_BASE_URL env var.
+            api_key: Custom LangFlow API key. If not provided, uses LANGFLOW_API_KEY env var.
+
+        Returns:
+            Response containing sync results and statistics
+        """
+        return self.agents.sync_langflow_agents(base_url=base_url, api_key=api_key)
+
+    # Tools
+    def create_tool(self, **kwargs) -> Tool:
+        """Create a new tool."""
+        return self.tools.create_tool(**kwargs)
+
+    def create_tool_from_code(self, **kwargs) -> Tool:
+        """Create a new tool from code."""
+        return self.tools.create_tool_from_code(**kwargs)
+
+    def list_tools(self, tool_type: str | None = None) -> list[Tool]:
+        """List tools with optional type filtering."""
+        return self.tools.list_tools(tool_type=tool_type)
+
+    def get_tool_by_id(self, tool_id: str) -> Tool | None:
+        """Get tool by ID."""
+        return self.tools.get_tool_by_id(tool_id)
+
+    def get_tool(self, tool_id: str) -> Tool | None:
+        """Backward-compatible alias for get_tool_by_id."""
+        return self.get_tool_by_id(tool_id)
+
+    def find_tools(self, name: str) -> list[Tool]:
+        """Find tools by name."""
+        return self.tools.find_tools(name)
+
+    def update_tool(self, tool_id: str, **kwargs) -> Tool:
+        """Update an existing tool."""
+        return self.tools.update_tool(tool_id, **kwargs)
+
+    def delete_tool(self, tool_id: str) -> bool:
+        """Delete a tool."""
+        return self.tools.delete_tool(tool_id)
+
+    def get_tool_script(self, tool_id: str) -> str:
+        """Get tool script content."""
+        return self.tools.get_tool_script(tool_id)
+
+    def update_tool_via_file(self, tool_id: str, file_path: str) -> Tool:
+        """Update tool via file."""
+        return self.tools.update_tool_via_file(tool_id, file_path)
+
+    # MCPs
+    def create_mcp(self, **kwargs) -> MCP:
+        """Create a new MCP."""
+        return self.mcps.create_mcp(**kwargs)
+
+    def list_mcps(self) -> list[MCP]:
+        """List all MCPs."""
+        return self.mcps.list_mcps()
+
+    def get_mcp_by_id(self, mcp_id: str) -> MCP | None:
+        """Get MCP by ID."""
+        return self.mcps.get_mcp_by_id(mcp_id)
+
+    def get_mcp(self, mcp_id: str) -> MCP | None:
+        """Backward-compatible alias for get_mcp_by_id."""
+        return self.get_mcp_by_id(mcp_id)
+
+    def find_mcps(self, name: str) -> list[MCP]:
+        """Find MCPs by name."""
+        return self.mcps.find_mcps(name)
+
+    def update_mcp(self, mcp_id: str, **kwargs) -> MCP:
+        """Update an existing MCP."""
+        return self.mcps.update_mcp(mcp_id, **kwargs)
+
+    def delete_mcp(self, mcp_id: str) -> bool:
+        """Delete an MCP."""
+        return self.mcps.delete_mcp(mcp_id)
+
+    def test_mcp_connection(self, config: dict) -> dict:
+        """Test MCP connection."""
+        return self.mcps.test_mcp_connection(config)
+
+    def test_mcp_connection_from_config(self, config: dict) -> dict:
+        """Test MCP connection from config."""
+        return self.mcps.test_mcp_connection_from_config(config)
+
+    def get_mcp_tools_from_config(self, config: dict) -> list[dict]:
+        """Get MCP tools from config."""
+        return self.mcps.get_mcp_tools_from_config(config)
+
+    # Language Models
+    def list_language_models(self) -> list[dict]:
+        """List available language models."""
+        data = self._request("GET", "/language-models")
+        return data or []
+
+    # ---- Timeout propagation ----
+    @property
+    def timeout(self) -> float:  # type: ignore[override]
+        return super().timeout
+
+    @timeout.setter
+    def timeout(self, value: float) -> None:  # type: ignore[override]
+        # Rebuild the root http client
+        BaseClient.timeout.fset(self, value)  # call parent setter
+        # Propagate the new session to sub-clients so they don't hold a closed client
+        try:
+            if hasattr(self, "agents"):
+                self.agents.http_client = self.http_client
+            if hasattr(self, "tools"):
+                self.tools.http_client = self.http_client
+            if hasattr(self, "mcps"):
+                self.mcps.http_client = self.http_client
+        except Exception:
+            pass
+
+    # ---- Health Check ----
+    def ping(self) -> bool:
+        """Check if the API is reachable."""
+        try:
+            self._request("GET", "/health-check")
+            return True
+        except Exception:
+            return False

glaip_sdk/client/mcps.py

@@ -9,9 +9,18 @@ import logging
 from typing import Any
 
 from glaip_sdk.client.base import BaseClient
+from glaip_sdk.config.constants import (
+    DEFAULT_MCP_TRANSPORT,
+    DEFAULT_MCP_TYPE,
+)
 from glaip_sdk.models import MCP
 from glaip_sdk.utils.client_utils import create_model_instances, find_by_name
 
+# API endpoints
+MCPS_ENDPOINT = "/mcps/"
+MCPS_CONNECT_ENDPOINT = "/mcps/connect"
+MCPS_CONNECT_TOOLS_ENDPOINT = "/mcps/connect/tools"
+
 # Set up module-level logger
 logger = logging.getLogger("glaip_sdk.mcps")
 
@@ -30,18 +39,18 @@ class MCPClient(BaseClient):
 
     def list_mcps(self) -> list[MCP]:
         """List all MCPs."""
-        data = self._request("GET", "/mcps/")
+        data = self._request("GET", MCPS_ENDPOINT)
         return create_model_instances(data, MCP, self)
 
     def get_mcp_by_id(self, mcp_id: str) -> MCP:
         """Get MCP by ID."""
-        data = self._request("GET", f"/mcps/{mcp_id}")
+        data = self._request("GET", f"{MCPS_ENDPOINT}{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/")
+        data = self._request("GET", MCPS_ENDPOINT)
         mcps = create_model_instances(data, MCP, self)
         return find_by_name(mcps, name, case_sensitive=False)
 
@@ -53,36 +62,152 @@ class MCPClient(BaseClient):
         **kwargs,
     ) -> MCP:
         """Create a new MCP."""
-        payload = {
-            "name": name,
-            "description": description,
+        # Use the helper method to build a properly structured payload
+        payload = self._build_create_payload(
+            name=name,
+            description=description,
+            config=config,
             **kwargs,
-        }
-
-        if config:
-            payload["config"] = config
+        )
 
         # Create the MCP and fetch full details
         full_mcp_data = self._post_then_fetch(
             id_key="id",
-            post_endpoint="/mcps/",
-            get_endpoint_fmt="/mcps/{id}",
+            post_endpoint=MCPS_ENDPOINT,
+            get_endpoint_fmt=f"{MCPS_ENDPOINT}{{id}}",
             json=payload,
         )
         return MCP(**full_mcp_data)._set_client(self)
 
     def update_mcp(self, mcp_id: str, **kwargs) -> MCP:
-        """Update an existing MCP."""
-        data = self._request("PUT", f"/mcps/{mcp_id}", json=kwargs)
+        """Update an existing MCP.
+
+        Automatically chooses between PUT (full update) and PATCH (partial update)
+        based on the provided fields:
+        - Uses PUT if name, config, and transport are all provided (full update)
+        - Uses PATCH otherwise (partial update)
+        """
+        # Check if all required fields for full update are provided
+        required_fields = {"name", "config", "transport"}
+        provided_fields = set(kwargs.keys())
+
+        if required_fields.issubset(provided_fields):
+            # All required fields provided - use full update (PUT)
+            method = "PUT"
+        else:
+            # Partial update - use PATCH
+            method = "PATCH"
+
+        data = self._request(method, f"{MCPS_ENDPOINT}{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}")
+        self._request("DELETE", f"{MCPS_ENDPOINT}{mcp_id}")
+
+    def _build_create_payload(
+        self,
+        name: str,
+        description: str,
+        transport: str = DEFAULT_MCP_TRANSPORT,
+        config: dict[str, Any] | None = None,
+        **kwargs,
+    ) -> dict[str, Any]:
+        """Build payload for MCP creation with proper metadata handling.
+
+        CENTRALIZED PAYLOAD BUILDING LOGIC:
+        - Sets proper defaults and required fields
+        - Handles config serialization consistently
+        - Processes transport and other metadata properly
+
+        Args:
+            name: MCP name
+            description: MCP description
+            transport: MCP transport protocol (defaults to stdio)
+            config: MCP configuration dictionary
+            **kwargs: Additional parameters
+
+        Returns:
+            Complete payload dictionary for MCP creation
+        """
+        # Prepare the creation payload with required fields
+        payload: dict[str, Any] = {
+            "name": name.strip(),
+            "type": DEFAULT_MCP_TYPE,  # MCPs are always server type
+            "transport": transport,
+        }
+
+        # Add description if provided
+        if description:
+            payload["description"] = description.strip()
+
+        # Handle config - ensure it's properly serialized
+        if config:
+            payload["config"] = config
+
+        # Add any other kwargs (excluding already handled ones)
+        excluded_keys = {"type"}  # type is handled above
+        for key, value in kwargs.items():
+            if key not in excluded_keys:
+                payload[key] = value
+
+        return payload
+
+    def _build_update_payload(
+        self,
+        current_mcp: MCP,
+        name: str | None = None,
+        description: str | None = None,
+        **kwargs,
+    ) -> dict[str, Any]:
+        """Build payload for MCP update with proper current state preservation.
+
+        Args:
+            current_mcp: Current MCP object to update
+            name: New MCP name (None to keep current)
+            description: New description (None to keep current)
+            **kwargs: Additional parameters (config, transport, etc.)
+
+        Returns:
+            Complete payload dictionary for MCP update
+
+        Notes:
+            - Preserves current values as defaults when new values not provided
+            - Handles config updates properly
+        """
+        # Prepare the update payload with current values as defaults
+        update_data = {
+            "name": name if name is not None else current_mcp.name,
+            "type": DEFAULT_MCP_TYPE,  # Required by backend, MCPs are always server type
+            "transport": kwargs.get(
+                "transport", getattr(current_mcp, "transport", DEFAULT_MCP_TRANSPORT)
+            ),
+        }
+
+        # Handle description with proper None handling
+        if description is not None:
+            update_data["description"] = description.strip()
+        elif hasattr(current_mcp, "description") and current_mcp.description:
+            update_data["description"] = current_mcp.description
+
+        # Handle config with proper merging
+        if "config" in kwargs:
+            update_data["config"] = kwargs["config"]
+        elif hasattr(current_mcp, "config") and current_mcp.config:
+            # Preserve existing config if present
+            update_data["config"] = current_mcp.config
+
+        # Add any other kwargs (excluding already handled ones)
+        excluded_keys = {"transport", "config"}
+        for key, value in kwargs.items():
+            if key not in excluded_keys:
+                update_data[key] = value
+
+        return update_data
 
     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")
+        data = self._request("GET", f"{MCPS_ENDPOINT}{mcp_id}/tools")
         return data or []
 
     def test_mcp_connection(self, config: dict[str, Any]) -> dict[str, Any]:
@@ -98,7 +223,7 @@ class MCPClient(BaseClient):
             Exception: If connection test fails
         """
         try:
-            response = self._request("POST", "/mcps/connect", json=config)
+            response = self._request("POST", MCPS_CONNECT_ENDPOINT, json=config)
             return response
         except Exception as e:
             logger.error(f"Failed to test MCP connection: {e}")
@@ -128,7 +253,7 @@ class MCPClient(BaseClient):
             Exception: If tool fetching fails
         """
         try:
-            response = self._request("POST", "/mcps/connect/tools", json=config)
+            response = self._request("POST", MCPS_CONNECT_TOOLS_ENDPOINT, json=config)
             if response is None:
                 return []
             return response.get("tools", []) or []