glaip-sdk 0.6.15b2__py3-none-any.whl → 0.6.15b3__py3-none-any.whl

glaip_sdk/client/main.py

@@ -0,0 +1,249 @@
+#!/usr/bin/env python3
+"""Main client for AIP SDK.
+
+Authors:
+    Raymond Christopher (raymond.christopher@gdplabs.id)
+    Christian Trisno Sen Long Chen (christian.t.s.l.chen@gdplabs.id)
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, 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.shared import build_shared_config
+from glaip_sdk.client.tools import ToolClient
+
+if TYPE_CHECKING:  # pragma: no cover
+    from glaip_sdk.agents import Agent
+    from glaip_sdk.client._agent_payloads import AgentListResult
+    from glaip_sdk.mcps import MCP
+    from glaip_sdk.tools import Tool
+
+
+class Client(BaseClient):
+    """Main client that composes all specialized clients and shares one HTTP session."""
+
+    def __init__(self, **kwargs):
+        """Initialize the main client.
+
+        Args:
+            **kwargs: Client configuration arguments (api_url, api_key, timeout, etc.)
+        """
+        super().__init__(**kwargs)
+        # Share the single httpx.Client + config with sub-clients
+        shared_config = build_shared_config(self)
+        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 create_agent_from_file(self, *args, **kwargs) -> Agent:
+        """Create a new agent from a JSON or YAML configuration file."""
+        return self.agents.create_agent_from_file(*args, **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,
+    ) -> AgentListResult:
+        """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:
+            AgentListResult with agents and pagination metadata. Supports iteration and indexing.
+        """
+        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 update_agent_from_file(self, agent_id: str, *args, **kwargs) -> Agent:
+        """Update an existing agent using a JSON or YAML configuration file."""
+        return self.agents.update_agent_from_file(agent_id, *args, **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, **kwargs) -> Tool:
+        """Update tool via file."""
+        return self.tools.update_tool_via_file(tool_id, file_path, **kwargs)
+
+    # 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]
+        """Get the client timeout value."""
+        return super().timeout
+
+    @timeout.setter
+    def timeout(self, value: float) -> None:  # type: ignore[override]
+        """Set the client timeout and propagate to sub-clients.
+
+        Args:
+            value: Timeout value in seconds.
+        """
+        # 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

@@ -0,0 +1,370 @@
+#!/usr/bin/env python3
+"""MCP client for AIP SDK.
+
+Authors:
+    Raymond Christopher (raymond.christopher@gdplabs.id)
+    Christian Trisno Sen Long Chen (christian.t.s.l.chen@gdplabs.id)
+"""
+
+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.mcps import MCP
+from glaip_sdk.models import MCPResponse
+from glaip_sdk.utils.client_utils import (
+    add_kwargs_to_payload,
+    create_model_instances,
+    find_by_name,
+)
+from glaip_sdk.utils.resource_refs import is_uuid
+
+# 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")
+
+
+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_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_ENDPOINT}{mcp_id}")
+        response = MCPResponse(**data)
+        return MCP.from_response(response, 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_ENDPOINT)
+        mcps = create_model_instances(data, MCP, self)
+        return find_by_name(mcps, name, case_sensitive=False)
+
+    def create_mcp(
+        self,
+        name: str,
+        description: str | None = None,
+        config: dict[str, Any] | None = None,
+        **kwargs,
+    ) -> MCP:
+        """Create a new MCP."""
+        # Use the helper method to build a properly structured payload
+        payload = self._build_create_payload(
+            name=name,
+            description=description,
+            config=config,
+            **kwargs,
+        )
+
+        # Create the MCP and fetch full details
+        full_mcp_data = self._post_then_fetch(
+            id_key="id",
+            post_endpoint=MCPS_ENDPOINT,
+            get_endpoint_fmt=f"{MCPS_ENDPOINT}{{id}}",
+            json=payload,
+        )
+        response = MCPResponse(**full_mcp_data)
+        return MCP.from_response(response, client=self)
+
+    def update_mcp(self, mcp_id: str, **kwargs) -> MCP:
+        """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)
+        response = MCPResponse(**data)
+        return MCP.from_response(response, client=self)
+
+    def delete_mcp(self, mcp_id: str) -> None:
+        """Delete an MCP."""
+        self._request("DELETE", f"{MCPS_ENDPOINT}{mcp_id}")
+
+    def upsert_mcp(
+        self,
+        identifier: str | MCP,
+        description: str | None = None,
+        config: dict[str, Any] | None = None,
+        **kwargs,
+    ) -> MCP:
+        """Create or update an MCP by instance, ID, or name.
+
+        Args:
+            identifier: MCP instance, ID (UUID string), or name
+            description: MCP description
+            config: MCP configuration dictionary
+            **kwargs: Additional parameters (transport, metadata, etc.)
+
+        Returns:
+            The created or updated MCP.
+
+        Example:
+            >>> # By name (creates if not exists)
+            >>> mcp = client.mcps.upsert_mcp(
+            ...     "deepwiki",
+            ...     transport="sse",
+            ...     config={"url": "https://mcp.deepwiki.com/sse"},
+            ... )
+            >>> # By instance
+            >>> mcp = client.mcps.upsert_mcp(existing_mcp, description="Updated")
+            >>> # By ID
+            >>> mcp = client.mcps.upsert_mcp("uuid-here", description="Updated")
+        """
+        # Handle MCP instance
+        if isinstance(identifier, MCP):
+            if identifier.id:
+                logger.info("Updating MCP by instance: %s", identifier.name)
+                return self._do_upsert_update(identifier.id, identifier.name, description, config, **kwargs)
+            # MCP without ID - treat name as identifier
+            identifier = identifier.name
+
+        # Handle string (ID or name)
+        if isinstance(identifier, str):
+            if is_uuid(identifier):
+                logger.info("Updating MCP by ID: %s", identifier)
+                existing = self.get_mcp_by_id(identifier)
+                return self._do_upsert_update(identifier, existing.name, description, config, **kwargs)
+
+            # It's a name - find or create
+            return self._upsert_by_name(identifier, description, config, **kwargs)
+
+        raise ValueError(f"Invalid identifier type: {type(identifier)}")
+
+    def _do_upsert_update(
+        self,
+        mcp_id: str,
+        name: str | None,
+        description: str | None,
+        config: dict[str, Any] | None,
+        **kwargs,
+    ) -> MCP:
+        """Perform the update part of upsert."""
+        update_kwargs = {**kwargs}
+        if name is not None:
+            update_kwargs["name"] = name
+        if description is not None:
+            update_kwargs["description"] = description
+        if config is not None:
+            update_kwargs["config"] = config
+        return self.update_mcp(mcp_id, **update_kwargs)
+
+    def _upsert_by_name(
+        self,
+        name: str,
+        description: str | None,
+        config: dict[str, Any] | None,
+        **kwargs,
+    ) -> MCP:
+        """Find by name and update, or create if not found."""
+        existing = self.find_mcps(name)
+
+        if len(existing) == 1:
+            logger.info("Updating existing MCP: %s", name)
+            return self._do_upsert_update(existing[0].id, name, description, config, **kwargs)
+
+        if len(existing) > 1:
+            raise ValueError(f"Multiple MCPs found with name '{name}'")
+
+        # Create new MCP
+        logger.info("Creating new MCP: %s", name)
+        return self.create_mcp(name=name, description=description, config=config, **kwargs)
+
+    def _build_create_payload(
+        self,
+        name: str,
+        description: str | None = None,
+        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 (optional)
+            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
+        add_kwargs_to_payload(payload, kwargs, excluded_keys)
+
+        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_ENDPOINT}{mcp_id}/tools")
+        if data is None:
+            return []
+        if isinstance(data, list):
+            return data
+        if isinstance(data, dict):
+            if "tools" in data:
+                return data.get("tools", []) or []
+            logger.warning(
+                "Unexpected MCP tools response keys %s; returning empty list",
+                list(data.keys()),
+            )
+            return []
+        logger.warning(
+            "Unexpected MCP tools response type %s; returning empty list",
+            type(data).__name__,
+        )
+        return []
+
+    def test_mcp_connection(self, config: dict[str, Any]) -> dict[str, Any]:
+        """Test MCP connection using configuration.
+
+        Args:
+            config: MCP configuration dictionary
+
+        Returns:
+            dict: Connection test result
+
+        Raises:
+            Exception: If connection test fails
+        """
+        try:
+            response = self._request("POST", MCPS_CONNECT_ENDPOINT, json=config)
+            return response
+        except Exception as e:
+            logger.error(f"Failed to test MCP connection: {e}")
+            raise
+
+    def test_mcp_connection_from_config(self, config: dict[str, Any]) -> dict[str, Any]:
+        """Test MCP connection using configuration (alias for test_mcp_connection).
+
+        Args:
+            config: MCP configuration dictionary
+
+        Returns:
+            dict: Connection test result
+        """
+        return self.test_mcp_connection(config)
+
+    def get_mcp_tools_from_config(self, config: dict[str, Any]) -> list[dict[str, Any]]:
+        """Fetch tools from MCP configuration without saving.
+
+        Args:
+            config: MCP configuration dictionary
+
+        Returns:
+            list: List of available tools from the MCP
+
+        Raises:
+            Exception: If tool fetching fails
+        """
+        try:
+            response = self._request("POST", MCPS_CONNECT_TOOLS_ENDPOINT, json=config)
+            if response is None:
+                return []
+            return response.get("tools", []) or []
+        except Exception as e:
+            logger.error(f"Failed to get MCP tools from config: {e}")
+            raise