glaip-sdk 0.0.2__py3-none-any.whl → 0.0.4__py3-none-any.whl

glaip_sdk/client/mcps.py

@@ -10,6 +10,7 @@ from typing import Any
 
 from glaip_sdk.client.base import BaseClient
 from glaip_sdk.models import MCP
+from glaip_sdk.utils.client_utils import create_model_instances, find_by_name
 
 # Set up module-level logger
 logger = logging.getLogger("glaip_sdk.mcps")
@@ -30,7 +31,7 @@ class MCPClient(BaseClient):
     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 [])]
+        return create_model_instances(data, MCP, self)
 
     def get_mcp_by_id(self, mcp_id: str) -> MCP:
         """Get MCP by ID."""
@@ -41,13 +42,8 @@ class MCPClient(BaseClient):
         """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
+        mcps = create_model_instances(data, MCP, self)
+        return find_by_name(mcps, name, case_sensitive=False)
 
     def create_mcp(
         self,
@@ -66,18 +62,14 @@ class MCPClient(BaseClient):
         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)
+        # 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}",
+            json=payload,
+        )
+        return MCP(**full_mcp_data)._set_client(self)
 
     def update_mcp(self, mcp_id: str, **kwargs) -> MCP:
         """Update an existing MCP."""
@@ -92,3 +84,54 @@ class MCPClient(BaseClient):
         """Get tools available from an MCP."""
         data = self._request("GET", f"/mcps/{mcp_id}/tools")
         return data or []
+
+    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", 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", 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

glaip_sdk/client/tools.py

@@ -6,9 +6,15 @@ Authors:
 """
 
 import logging
+import os
+import tempfile
 
 from glaip_sdk.client.base import BaseClient
 from glaip_sdk.models import Tool
+from glaip_sdk.utils.client_utils import (
+    create_model_instances,
+    find_by_name,
+)
 
 # Set up module-level logger
 logger = logging.getLogger("glaip_sdk.tools")
@@ -29,7 +35,7 @@ class ToolClient(BaseClient):
     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 [])]
+        return create_model_instances(data, Tool, self)
 
     def get_tool_by_id(self, tool_id: str) -> Tool:
         """Get tool by ID."""
@@ -40,81 +46,190 @@ class ToolClient(BaseClient):
         """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 [])]
+        tools = create_model_instances(data, Tool, self)
+        return find_by_name(tools, name, case_sensitive=False)
 
-        if name:
-            # Client-side filtering by name (case-insensitive)
-            tools = [tool for tool in tools if name.lower() in tool.name.lower()]
+    def _validate_and_read_file(self, file_path: str) -> str:
+        """Validate file exists and read its content.
 
-        return tools
+        Args:
+            file_path: Path to the file to read
 
-    def create_tool(
+        Returns:
+            str: File content
+
+        Raises:
+            FileNotFoundError: If file doesn't exist
+        """
+        if not os.path.exists(file_path):
+            raise FileNotFoundError(f"Tool file not found: {file_path}")
+
+        with open(file_path, encoding="utf-8") as f:
+            return f.read()
+
+    def _extract_name_from_file(self, file_path: str) -> str:
+        """Extract tool name from file path.
+
+        Args:
+            file_path: Path to the file
+
+        Returns:
+            str: Extracted name (filename without extension)
+        """
+        return os.path.splitext(os.path.basename(file_path))[0]
+
+    def _prepare_upload_data(
+        self, name: str, framework: str, description: str | None = None, **kwargs
+    ) -> dict:
+        """Prepare upload data dictionary.
+
+        Args:
+            name: Tool name
+            framework: Tool framework
+            description: Optional description
+            **kwargs: Additional parameters
+
+        Returns:
+            dict: Upload data dictionary
+        """
+        data = {
+            "name": name,
+            "framework": framework,
+        }
+
+        if description:
+            data["description"] = description
+
+        # Handle tags if provided in kwargs
+        if "tags" in kwargs and kwargs["tags"]:
+            if isinstance(kwargs["tags"], list):
+                data["tags"] = ",".join(kwargs["tags"])
+            else:
+                data["tags"] = kwargs["tags"]
+
+        # Include any other kwargs in the upload data
+        for key, value in kwargs.items():
+            if key not in ["tags"]:  # tags already handled above
+                data[key] = value
+
+        return data
+
+    def _upload_tool_file(self, file_path: str, upload_data: dict) -> Tool:
+        """Upload tool file to server.
+
+        Args:
+            file_path: Path to temporary file to upload
+            upload_data: Dictionary with upload metadata
+
+        Returns:
+            Tool: Created tool object
+        """
+        with open(file_path, "rb") as fb:
+            files = {
+                "file": (os.path.basename(file_path), fb, "application/octet-stream"),
+            }
+
+            response = self._request(
+                "POST",
+                "/tools/upload",
+                files=files,
+                data=upload_data,
+            )
+
+        return Tool(**response)._set_client(self)
+
+    def _create_tool_from_file(
         self,
+        file_path: str,
         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.
+        """Create tool from file content using upload endpoint.
 
         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
+            file_path: Path to tool file
+            name: Optional tool name (auto-detected if not provided)
+            description: Optional tool description
+            framework: Tool framework
+            **kwargs: Additional parameters
+
+        Returns:
+            Tool: Created tool object
         """
-        # Handle compatibility parameters
-        if file_path and not tool_file:
-            tool_file = file_path
-        if code and not tool_script:
-            tool_script = code
+        # Read and validate file
+        file_content = self._validate_and_read_file(file_path)
 
-        # Auto-detect name from file if not provided
-        if not name and tool_file:
-            import os
+        # Auto-detect name if not provided
+        if not name:
+            name = self._extract_name_from_file(file_path)
 
-            name = os.path.splitext(os.path.basename(tool_file))[0]
+        # Handle description - generate default if not provided or empty
+        if description is None or description == "":
+            # Generate default description based on tool_type if available
+            tool_type = kwargs.get("tool_type", "custom")
+            description = f"A {tool_type} tool"
 
-        if not name:
-            raise ValueError(
-                "Tool name is required (either explicitly or via file path)"
+        # Create temporary file for upload
+        with tempfile.NamedTemporaryFile(
+            mode="w",
+            suffix=".py",
+            prefix=f"{name}_",
+            delete=False,
+            encoding="utf-8",
+        ) as temp_file:
+            temp_file.write(file_content)
+            temp_file_path = temp_file.name
+
+        try:
+            # Prepare upload data
+            upload_data = self._prepare_upload_data(
+                name=name, framework=framework, description=description, **kwargs
             )
 
-        # Auto-detect description if not provided
-        if not description:
-            description = f"A {tool_type} tool"
+            # Upload file
+            return self._upload_tool_file(temp_file_path, upload_data)
 
-        payload = {
-            "name": name,
-            "tool_type": tool_type,
-            "description": description,
-            "framework": framework,
-            **kwargs,
-        }
+        finally:
+            # Clean up temporary file
+            try:
+                os.unlink(temp_file_path)
+            except OSError:
+                pass  # Ignore cleanup errors
 
-        if tool_script:
-            payload["tool_script"] = tool_script
-        if tool_file:
-            payload["tool_file"] = tool_file
+    def create_tool(
+        self,
+        file_path: str,
+        name: str | None = None,
+        description: str | None = None,
+        framework: str = "langchain",
+        **kwargs,
+    ) -> Tool:
+        """Create a new tool from a file.
 
-        data = self._request("POST", "/tools/", json=payload)
-        return Tool(**data)._set_client(self)
+        Args:
+            file_path: File path to tool script (required) - file content will be read and processed as plugin
+            name: Tool name (auto-detected from file if not provided)
+            description: Tool description (auto-generated if not provided)
+            framework: Tool framework (defaults to "langchain")
+            **kwargs: Additional tool parameters
+        """
+        return self._create_tool_from_file(
+            file_path=file_path,
+            name=name,
+            description=description,
+            framework=framework,
+            **kwargs,
+        )
 
     def create_tool_from_code(
         self,
         name: str,
         code: str,
         framework: str = "langchain",
+        description: str | None = None,
+        tags: list[str] | None = None,
     ) -> Tool:
         """Create a new tool plugin from code string.
 
@@ -126,38 +241,35 @@ class ToolClient(BaseClient):
             name: Name for the tool (used for temporary file naming)
             code: Python code containing the tool plugin
             framework: Tool framework (defaults to "langchain")
+            description: Optional tool description
+            tags: Optional list of tags
 
         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"
+            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)
+            # Prepare upload data using shared helper
+            upload_data = self._prepare_upload_data(
+                name=name,
+                framework=framework,
+                description=description,
+                tags=tags if tags else None,
+            )
 
-            # Use multipart form data for file upload
-            files = {"file": (file_obj.name, file_obj, "text/plain")}
-            data = {"framework": framework}
+            # Upload file using shared helper
+            return self._upload_tool_file(temp_file_path, upload_data)
 
-            # 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:
@@ -174,20 +286,63 @@ class ToolClient(BaseClient):
         """Delete a tool."""
         self._request("DELETE", f"/tools/{tool_id}")
 
-    def install_tool(self, tool_id: str) -> bool:
-        """Install a tool."""
+    def get_tool_script(self, tool_id: str) -> str:
+        """Get the tool script content.
+
+        Args:
+            tool_id: The ID of the tool
+
+        Returns:
+            str: The tool script content
+
+        Raises:
+            Exception: If the tool script cannot be retrieved
+        """
         try:
-            self._request("POST", f"/tools/{tool_id}/install")
-            return True
+            response = self._request("GET", f"/tools/{tool_id}/script")
+            return response.get("script", "") or response.get("content", "")
         except Exception as e:
-            logger.error(f"Failed to install tool {tool_id}: {e}")
-            return False
+            logger.error(f"Failed to get tool script for {tool_id}: {e}")
+            raise
+
+    def update_tool_via_file(self, tool_id: str, file_path: str, **kwargs) -> Tool:
+        """Update a tool plugin via file upload.
+
+        Args:
+            tool_id: The ID of the tool to update
+            file_path: Path to the new tool file
+            **kwargs: Additional metadata to update (name, description, tags, etc.)
+
+        Returns:
+            Tool: The updated tool object
+
+        Raises:
+            FileNotFoundError: If the file doesn't exist
+            Exception: If the update fails
+        """
+        # Validate file exists
+        self._validate_and_read_file(file_path)
 
-    def uninstall_tool(self, tool_id: str) -> bool:
-        """Uninstall a tool."""
         try:
-            self._request("POST", f"/tools/{tool_id}/uninstall")
-            return True
+            # Prepare multipart upload
+            with open(file_path, "rb") as fb:
+                files = {
+                    "file": (
+                        os.path.basename(file_path),
+                        fb,
+                        "application/octet-stream",
+                    ),
+                }
+
+                response = self._request(
+                    "PUT",
+                    f"/tools/{tool_id}/upload",
+                    files=files,
+                    data=kwargs,  # Pass kwargs directly as data
+                )
+
+            return Tool(**response)._set_client(self)
+
         except Exception as e:
-            logger.error(f"Failed to uninstall tool {tool_id}: {e}")
-            return False
+            logger.error(f"Failed to update tool {tool_id} via file: {e}")
+            raise

glaip_sdk/config/constants.py

@@ -10,11 +10,12 @@ DEFAULT_MODEL_PROVIDER = "openai"
 
 # Default timeout values
 DEFAULT_TIMEOUT = 30.0
-DEFAULT_AGENT_TIMEOUT = 300.0
+DEFAULT_AGENT_RUN_TIMEOUT = 300.0
+
+# User agent and version
 
-# User agent
 SDK_NAME = "glaip-sdk"
-SDK_VERSION = "0.1.1"
+SDK_VERSION = "0.1.0"
 
 # Reserved names that cannot be used for agents/tools
 RESERVED_NAMES = {
@@ -26,3 +27,9 @@ RESERVED_NAMES = {
     "demo",
     "sample",
 }
+
+# Agent creation/update constants
+DEFAULT_AGENT_TYPE = "config"
+DEFAULT_AGENT_FRAMEWORK = "langchain"
+DEFAULT_AGENT_VERSION = "1.0"
+DEFAULT_AGENT_PROVIDER = "openai"

glaip_sdk/exceptions.py

@@ -87,6 +87,19 @@ class TimeoutError(APIError):
     pass
 
 
+class AgentTimeoutError(TimeoutError):
+    """Agent execution timeout with specific duration information."""
+
+    def __init__(self, timeout_seconds: float, agent_name: str = None):
+        agent_info = f" for agent '{agent_name}'" if agent_name else ""
+        message = (
+            f"Agent execution timed out after {timeout_seconds} seconds{agent_info}"
+        )
+        super().__init__(message)
+        self.timeout_seconds = timeout_seconds
+        self.agent_name = agent_name
+
+
 class ClientError(APIError):
     """Client-side error (e.g., invalid request format, missing parameters)."""
 

glaip_sdk/models.py

@@ -5,10 +5,13 @@ Authors:
     Raymond Christopher (raymond.christopher@gdplabs.id)
 """
 
+from datetime import datetime
 from typing import Any
 
 from pydantic import BaseModel
 
+from glaip_sdk.config.constants import DEFAULT_AGENT_RUN_TIMEOUT
+
 
 class Agent(BaseModel):
     """Agent model for API responses."""
@@ -22,11 +25,17 @@ class Agent(BaseModel):
     version: str | None = None
     tools: list[dict[str, Any]] | None = None  # Backend returns ToolReference objects
     agents: list[dict[str, Any]] | None = None  # Backend returns AgentReference objects
+    mcps: list[dict[str, Any]] | None = None  # Backend returns MCPReference objects
+    tool_configs: dict[str, Any] | None = (
+        None  # Backend returns tool configurations keyed by tool UUID
+    )
     agent_config: dict[str, Any] | None = None
-    timeout: int = 300
+    timeout: int = DEFAULT_AGENT_RUN_TIMEOUT
     metadata: dict[str, Any] | None = None
     language_model_id: str | None = None
     a2a_profile: dict[str, Any] | None = None
+    created_at: datetime | None = None  # Backend returns creation timestamp
+    updated_at: datetime | None = None  # Backend returns last update timestamp
     _client: Any = None
 
     def _set_client(self, client):
@@ -34,15 +43,22 @@ class Agent(BaseModel):
         self._client = client
         return self
 
-    def run(self, message: str, **kwargs) -> str:
-        """Run the agent with a message."""
+    def run(self, message: str, verbose: bool = False, **kwargs) -> str:
+        """Run the agent with a message.
+
+        Args:
+            message: The message to send to the agent
+            verbose: Enable verbose output and event JSON logging
+            **kwargs: Additional arguments passed to run_agent
+        """
         if not self._client:
             raise RuntimeError(
                 "No client available. Use client.get_agent_by_id() to get a client-connected agent."
             )
         # Automatically pass the agent name for better renderer display
         kwargs.setdefault("agent_name", self.name)
-        return self._client.run_agent(self.id, message, **kwargs)
+        # Pass verbose flag through to enable event JSON output
+        return self._client.run_agent(self.id, message, verbose=verbose, **kwargs)
 
     def update(self, **kwargs) -> "Agent":
         """Update agent attributes."""
@@ -112,7 +128,7 @@ class Tool(BaseModel):
             raise RuntimeError(
                 "No client available. Use client.get_tool_by_id() to get a client-connected tool."
             )
-        self._client.tools.delete_tool(self.id)
+        self._client.delete_tool(self.id)
 
 
 class MCP(BaseModel):