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

glaip_sdk/client/tools.py

@@ -8,14 +8,25 @@ Authors:
 import logging
 import os
 import tempfile
+from typing import Any
 
 from glaip_sdk.client.base import BaseClient
+from glaip_sdk.config.constants import (
+    DEFAULT_TOOL_FRAMEWORK,
+    DEFAULT_TOOL_TYPE,
+    DEFAULT_TOOL_VERSION,
+)
 from glaip_sdk.models import Tool
 from glaip_sdk.utils.client_utils import (
     create_model_instances,
     find_by_name,
 )
 
+# API endpoints
+TOOLS_ENDPOINT = "/tools/"
+TOOLS_UPLOAD_ENDPOINT = "/tools/upload"
+TOOLS_UPLOAD_BY_ID_ENDPOINT_FMT = "/tools/{tool_id}/upload"
+
 # Set up module-level logger
 logger = logging.getLogger("glaip_sdk.tools")
 
@@ -32,84 +43,320 @@ class ToolClient(BaseClient):
         """
         super().__init__(parent_client=parent_client, **kwargs)
 
-    def list_tools(self) -> list[Tool]:
-        """List all tools."""
-        data = self._request("GET", "/tools/")
+    def list_tools(self, tool_type: str | None = None) -> list[Tool]:
+        """List all tools, optionally filtered by type.
+
+        Args:
+            tool_type: Filter tools by type (e.g., "custom", "native")
+        """
+        endpoint = TOOLS_ENDPOINT
+        if tool_type:
+            endpoint += f"?type={tool_type}"
+        data = self._request("GET", endpoint)
         return create_model_instances(data, Tool, self)
 
     def get_tool_by_id(self, tool_id: str) -> Tool:
         """Get tool by ID."""
-        data = self._request("GET", f"/tools/{tool_id}")
+        data = self._request("GET", f"{TOOLS_ENDPOINT}{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/")
+        data = self._request("GET", TOOLS_ENDPOINT)
         tools = create_model_instances(data, Tool, self)
         return find_by_name(tools, name, case_sensitive=False)
 
-    def create_tool(
+    def _validate_and_read_file(self, file_path: str) -> str:
+        """Validate file exists and read its content.
+
+        Args:
+            file_path: Path to the file to read
+
+        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 kwargs.get("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_ENDPOINT,
+                files=files,
+                data=upload_data,
+            )
+
+        return Tool(**response)._set_client(self)
+
+    def _build_create_payload(
+        self,
+        name: str,
+        description: str | None = None,
+        framework: str = DEFAULT_TOOL_FRAMEWORK,
+        tool_type: str = DEFAULT_TOOL_TYPE,
+        **kwargs,
+    ) -> dict[str, Any]:
+        """Build payload for tool creation with proper metadata handling.
+
+        CENTRALIZED PAYLOAD BUILDING LOGIC:
+        - Handles file vs metadata-only tool creation
+        - Sets proper defaults and required fields
+        - Processes tags and other metadata consistently
+
+        Args:
+            name: Tool name
+            description: Tool description
+            framework: Tool framework (defaults to langchain)
+            tool_type: Tool type (defaults to custom)
+            **kwargs: Additional parameters (tags, version, etc.)
+
+        Returns:
+            Complete payload dictionary for tool creation
+        """
+        # Prepare the creation payload with required fields
+        payload: dict[str, any] = {
+            "name": name.strip(),
+            "type": tool_type,
+            "framework": framework,
+            "version": kwargs.get("version", DEFAULT_TOOL_VERSION),
+        }
+
+        # Add description if provided
+        if description:
+            payload["description"] = description.strip()
+
+        # Handle tags - convert list to comma-separated string for API
+        if kwargs.get("tags"):
+            if isinstance(kwargs["tags"], list):
+                payload["tags"] = ",".join(str(tag).strip() for tag in kwargs["tags"])
+            else:
+                payload["tags"] = str(kwargs["tags"])
+
+        # Add any other kwargs (excluding already handled ones)
+        excluded_keys = {"tags", "version"}
+        for key, value in kwargs.items():
+            if key not in excluded_keys:
+                payload[key] = value
+
+        return payload
+
+    def _build_update_payload(
         self,
+        current_tool: Tool,
+        name: str | None = None,
+        description: str | None = None,
+        **kwargs,
+    ) -> dict[str, Any]:
+        """Build payload for tool update with proper current state preservation.
+
+        Args:
+            current_tool: Current tool object to update
+            name: New tool name (None to keep current)
+            description: New description (None to keep current)
+            **kwargs: Additional parameters (tags, framework, etc.)
+
+        Returns:
+            Complete payload dictionary for tool update
+
+        Notes:
+            - Preserves current values as defaults when new values not provided
+            - Handles metadata updates properly
+        """
+        # Prepare the update payload with current values as defaults
+        update_data = {
+            "name": name if name is not None else current_tool.name,
+            "type": DEFAULT_TOOL_TYPE,  # Required by backend
+            "framework": kwargs.get(
+                "framework", getattr(current_tool, "framework", DEFAULT_TOOL_FRAMEWORK)
+            ),
+            "version": kwargs.get(
+                "version", getattr(current_tool, "version", DEFAULT_TOOL_VERSION)
+            ),
+        }
+
+        # Handle description with proper None handling
+        if description is not None:
+            update_data["description"] = description.strip()
+        elif hasattr(current_tool, "description") and current_tool.description:
+            update_data["description"] = current_tool.description
+
+        # Handle tags - convert list to comma-separated string for API
+        if kwargs.get("tags"):
+            if isinstance(kwargs["tags"], list):
+                update_data["tags"] = ",".join(
+                    str(tag).strip() for tag in kwargs["tags"]
+                )
+            else:
+                update_data["tags"] = str(kwargs["tags"])
+        elif hasattr(current_tool, "tags") and current_tool.tags:
+            # Preserve existing tags if present
+            if isinstance(current_tool.tags, list):
+                update_data["tags"] = ",".join(
+                    str(tag).strip() for tag in current_tool.tags
+                )
+            else:
+                update_data["tags"] = str(current_tool.tags)
+
+        # Add any other kwargs (excluding already handled ones)
+        excluded_keys = {"tags", "framework", "version"}
+        for key, value in kwargs.items():
+            if key not in excluded_keys:
+                update_data[key] = value
+
+        return update_data
+
+    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,
@@ -129,41 +376,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
         """
         # 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:
-            # Prepare multipart upload
-            filename = os.path.basename(temp_file_path)
-            with open(temp_file_path, "rb") as fb:
-                files = {
-                    "file": (filename, fb, "application/octet-stream"),
-                }
-                data = {
-                    "name": name,
-                    "framework": framework,
-                }
-                if description:
-                    data["description"] = description
-                if tags:
-                    # Backend might expect comma-separated or JSON; start with comma-separated
-                    data["tags"] = ",".join(tags)
+            # Prepare upload data using shared helper
+            upload_data = self._prepare_upload_data(
+                name=name,
+                framework=framework,
+                description=description,
+                tags=tags if tags else None,
+            )
+
+            # Upload file using shared helper
+            return self._upload_tool_file(temp_file_path, upload_data)
 
-                response = self._request(
-                    "POST",
-                    "/tools/upload",
-                    files=files,
-                    data=data,
-                )
-            return Tool(**response)._set_client(self)
         finally:
             # Clean up the temporary file
             try:
@@ -173,30 +414,12 @@ class ToolClient(BaseClient):
 
     def update_tool(self, tool_id: str, **kwargs) -> Tool:
         """Update an existing tool."""
-        data = self._request("PUT", f"/tools/{tool_id}", json=kwargs)
+        data = self._request("PUT", f"{TOOLS_ENDPOINT}{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 install tool {tool_id}: {e}")
-            return False
+        self._request("DELETE", f"{TOOLS_ENDPOINT}{tool_id}")
 
     def get_tool_script(self, tool_id: str) -> str:
         """Get the tool script content.
@@ -211,7 +434,7 @@ class ToolClient(BaseClient):
             Exception: If the tool script cannot be retrieved
         """
         try:
-            response = self._request("GET", f"/tools/{tool_id}/script")
+            response = self._request("GET", f"{TOOLS_ENDPOINT}{tool_id}/script")
             return response.get("script", "") or response.get("content", "")
         except Exception as e:
             logger.error(f"Failed to get tool script for {tool_id}: {e}")
@@ -232,29 +455,29 @@ class ToolClient(BaseClient):
             FileNotFoundError: If the file doesn't exist
             Exception: If the update fails
         """
-        import os
-
-        if not os.path.exists(file_path):
-            raise FileNotFoundError(f"Tool file not found: {file_path}")
+        # Validate file exists
+        self._validate_and_read_file(file_path)
 
         try:
             # Prepare multipart upload
-            filename = os.path.basename(file_path)
             with open(file_path, "rb") as fb:
                 files = {
-                    "file": (filename, fb, "application/octet-stream"),
+                    "file": (
+                        os.path.basename(file_path),
+                        fb,
+                        "application/octet-stream",
+                    ),
                 }
 
-                # Add any additional metadata
-                data = kwargs.copy()
-
                 response = self._request(
                     "PUT",
-                    f"/tools/{tool_id}/upload",
+                    TOOLS_UPLOAD_BY_ID_ENDPOINT_FMT.format(tool_id=tool_id),
                     files=files,
-                    data=data,
+                    data=kwargs,  # Pass kwargs directly as data
                 )
+
             return Tool(**response)._set_client(self)
+
         except Exception as e:
             logger.error(f"Failed to update tool {tool_id} via file: {e}")
             raise

glaip_sdk/config/constants.py

@@ -10,7 +10,7 @@ DEFAULT_MODEL_PROVIDER = "openai"
 
 # Default timeout values
 DEFAULT_TIMEOUT = 30.0
-DEFAULT_AGENT_RUN_TIMEOUT = 300.0
+DEFAULT_AGENT_RUN_TIMEOUT = 300
 
 # User agent and version
 
@@ -33,3 +33,12 @@ 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"

glaip_sdk/models.py

@@ -5,6 +5,7 @@ Authors:
     Raymond Christopher (raymond.christopher@gdplabs.id)
 """
 
+from collections.abc import AsyncGenerator
 from datetime import datetime
 from typing import Any
 
@@ -60,6 +61,31 @@ class Agent(BaseModel):
         # Pass verbose flag through to enable event JSON output
         return self._client.run_agent(self.id, message, verbose=verbose, **kwargs)
 
+    async def arun(self, message: str, **kwargs) -> AsyncGenerator[dict, None]:
+        """Async run the agent with a message, yielding streaming JSON chunks.
+
+        Args:
+            message: The message to send to the agent
+            **kwargs: Additional arguments passed to arun_agent
+
+        Yields:
+            Dictionary containing parsed JSON chunks from the streaming response
+
+        Raises:
+            RuntimeError: When no client is available
+            AgentTimeoutError: When agent execution times out
+            Exception: For other unexpected errors
+        """
+        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 context
+        kwargs.setdefault("agent_name", self.name)
+
+        async for chunk in self._client.arun_agent(self.id, message, **kwargs):
+            yield chunk
+
     def update(self, **kwargs) -> "Agent":
         """Update agent attributes."""
         if not self._client:
@@ -110,12 +136,26 @@ class Tool(BaseModel):
             return "No script content available"
 
     def update(self, **kwargs) -> "Tool":
-        """Update tool attributes."""
+        """Update tool attributes.
+
+        Supports both metadata updates and file uploads.
+        Pass 'file' parameter to update tool code via file upload.
+        """
         if not self._client:
             raise RuntimeError(
                 "No client available. Use client.get_tool_by_id() to get a client-connected tool."
             )
-        updated_tool = self._client.tools.update_tool(self.id, **kwargs)
+
+        # Check if file upload is requested
+        if "file" in kwargs:
+            file_path = kwargs.pop("file")  # Remove file from kwargs for metadata
+            updated_tool = self._client.tools.update_tool_via_file(
+                self.id, file_path, **kwargs
+            )
+        else:
+            # Regular metadata update
+            updated_tool = self._client.tools.update_tool(self.id, **kwargs)
+
         # Update current instance with new data
         for key, value in updated_tool.model_dump().items():
             if hasattr(self, key):
@@ -128,7 +168,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):

glaip_sdk/rich_components.py

@@ -0,0 +1,29 @@
+"""Custom Rich components with copy-friendly defaults."""
+
+from __future__ import annotations
+
+from rich import box
+from rich.panel import Panel
+from rich.table import Table
+
+
+class AIPPanel(Panel):
+    """Rich Panel configured without vertical borders by default."""
+
+    def __init__(self, *args, **kwargs):
+        kwargs.setdefault("box", box.HORIZONTALS)
+        kwargs.setdefault("padding", (0, 1))
+        super().__init__(*args, **kwargs)
+
+
+class AIPTable(Table):
+    """Rich Table configured without vertical borders by default."""
+
+    def __init__(self, *args, **kwargs):
+        kwargs.setdefault("box", box.HORIZONTALS)
+        kwargs.setdefault("show_edge", False)
+        kwargs.setdefault("pad_edge", False)
+        super().__init__(*args, **kwargs)
+
+
+__all__ = ["AIPPanel", "AIPTable"]