glaip-sdk 0.0.2__py3-none-any.whl → 0.0.3__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
 
+from glaip_sdk.config.constants import SDK_NAME, SDK_VERSION
 from glaip_sdk.exceptions import (
     AuthenticationError,
     ConflictError,
@@ -82,7 +83,15 @@ class BaseClient:
 
     def _build_client(self, timeout: float) -> httpx.Client:
         """Build HTTP client with configuration."""
-        from glaip_sdk.config.constants import SDK_NAME, SDK_VERSION
+        # 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 httpx.Client(
             base_url=self.api_url,
@@ -90,7 +99,7 @@ class BaseClient:
                 "X-API-Key": self.api_key,
                 "User-Agent": f"{SDK_NAME}/{SDK_VERSION}",
             },
-            timeout=httpx.Timeout(timeout),
+            timeout=timeout_config,
             follow_redirects=True,
             http2=False,
             limits=httpx.Limits(max_keepalive_connections=10, max_connections=100),
@@ -113,6 +122,57 @@ class BaseClient:
             self.http_client.close()
             self.http_client = self._build_client(value)
 
+    def _post_then_fetch(
+        self,
+        id_key: str,
+        post_endpoint: str,
+        get_endpoint_fmt: str,
+        *,
+        json=None,
+        data=None,
+        files=None,
+        **kwargs,
+    ) -> Any:
+        """Helper for POST-then-GET pattern used in create methods.
+
+        Args:
+            id_key: Key in POST response containing the ID
+            post_endpoint: Endpoint for POST request
+            get_endpoint_fmt: Format string for GET endpoint (e.g., "/items/{id}")
+            json: JSON data for POST
+            data: Form data for POST
+            files: Files for POST
+            **kwargs: Additional kwargs for POST
+
+        Returns:
+            Full resource data from GET request
+        """
+        # Create the resource
+        post_kwargs = {}
+        if json is not None:
+            post_kwargs["json"] = json
+        if data is not None:
+            post_kwargs["data"] = data
+        if files is not None:
+            post_kwargs["files"] = files
+        post_kwargs.update(kwargs)
+
+        response_data = self._request("POST", post_endpoint, **post_kwargs)
+
+        # Extract the ID
+        if isinstance(response_data, dict):
+            resource_id = response_data.get(id_key)
+        else:
+            # Fallback: assume response_data is the ID directly
+            resource_id = str(response_data)
+
+        if not resource_id:
+            raise ValueError(f"Backend did not return {id_key}")
+
+        # Fetch the full resource details
+        get_endpoint = get_endpoint_fmt.format(id=resource_id)
+        return self._request("GET", get_endpoint)
+
     def _request(self, method: str, endpoint: str, **kwargs) -> Any:
         """Make HTTP request with error handling."""
         client_log.debug(f"Making {method} request to {endpoint}")

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,13 +46,8 @@ 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 [])]
-
-        if name:
-            # Client-side filtering by name (case-insensitive)
-            tools = [tool for tool in tools if name.lower() in tool.name.lower()]
-
-        return tools
+        tools = create_model_instances(data, Tool, self)
+        return find_by_name(tools, name, case_sensitive=False)
 
     def create_tool(
         self,
@@ -115,6 +116,8 @@ class ToolClient(BaseClient):
         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.
 
@@ -130,9 +133,6 @@ class ToolClient(BaseClient):
         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"
@@ -141,22 +141,28 @@ class ToolClient(BaseClient):
             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)
+            # 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)
+
+                response = self._request(
+                    "POST",
+                    "/tools/upload",
+                    files=files,
+                    data=data,
+                )
             return Tool(**response)._set_client(self)
         finally:
             # Clean up the temporary file
@@ -189,5 +195,66 @@ class ToolClient(BaseClient):
             self._request("POST", f"/tools/{tool_id}/uninstall")
             return True
         except Exception as e:
-            logger.error(f"Failed to uninstall tool {tool_id}: {e}")
+            logger.error(f"Failed to install tool {tool_id}: {e}")
             return False
+
+    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:
+            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 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
+        """
+        import os
+
+        if not os.path.exists(file_path):
+            raise FileNotFoundError(f"Tool file not found: {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"),
+                }
+
+                # Add any additional metadata
+                data = kwargs.copy()
+
+                response = self._request(
+                    "PUT",
+                    f"/tools/{tool_id}/upload",
+                    files=files,
+                    data=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,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."""

glaip_sdk/utils/__init__.py

@@ -7,23 +7,24 @@ Authors:
 import re
 from uuid import UUID
 
-from .run_renderer import (
-    RichStreamRenderer,
-    RunStats,
-    Step,
-    StepManager,
-)
+import click
 
-__all__ = [
-    "RichStreamRenderer",
-    "RunStats",
-    "Step",
-    "StepManager",
-    "is_uuid",
-    "sanitize_name",
-    "format_file_size",
-    "progress_bar",
-]
+from .rendering.models import RunStats, Step
+from .rendering.steps import StepManager
+from .run_renderer import RichStreamRenderer
+
+# Rich imports with availability check
+try:
+    from rich import box
+    from rich.console import Console
+    from rich.panel import Panel
+    from rich.text import Text
+
+    RICH_AVAILABLE = True
+except ImportError:
+    RICH_AVAILABLE = False
+
+# Functions are defined below in this file
 
 
 def is_uuid(value: str) -> bool:
@@ -84,8 +85,6 @@ def progress_bar(iterable, description: str = "Processing"):
         Items from iterable with progress display
     """
     try:
-        import click
-
         with click.progressbar(iterable, label=description) as bar:
             for item in bar:
                 yield item
@@ -93,3 +92,102 @@ def progress_bar(iterable, description: str = "Processing"):
         # Fallback if click not available
         for item in iterable:
             yield item
+
+
+# Rich display utilities for enhanced output
+# RICH_AVAILABLE is determined by the try/except block above
+
+
+def print_agent_output(output: str, title: str = "Agent Output") -> None:
+    """Print agent output with rich formatting.
+
+    Args:
+        output: The agent's response text
+        title: Title for the output panel
+    """
+    if RICH_AVAILABLE:
+        console = Console()
+        panel = Panel(
+            Text(output, style="green"),
+            title=title,
+            border_style="green",
+            box=box.ROUNDED,
+        )
+        console.print(panel)
+    else:
+        print(f"\n=== {title} ===")
+        print(output)
+        print("=" * (len(title) + 8))
+
+
+def print_agent_created(agent, title: str = "🤖 Agent Created") -> None:
+    """Print agent creation success with rich formatting.
+
+    Args:
+        agent: The created agent object
+        title: Title for the output panel
+    """
+    if RICH_AVAILABLE:
+        console = Console()
+        panel = Panel(
+            f"[green]✅ Agent '{agent.name}' created successfully![/green]\n\n"
+            f"ID: {agent.id}\n"
+            f"Model: {getattr(agent, 'model', 'N/A')}\n"
+            f"Type: {getattr(agent, 'type', 'config')}\n"
+            f"Framework: {getattr(agent, 'framework', 'langchain')}\n"
+            f"Version: {getattr(agent, 'version', '1.0')}",
+            title=title,
+            border_style="green",
+            box=box.ROUNDED,
+        )
+        console.print(panel)
+    else:
+        print(f"✅ Agent '{agent.name}' created successfully!")
+        print(f"ID: {agent.id}")
+        print(f"Model: {getattr(agent, 'model', 'N/A')}")
+        print(f"Type: {getattr(agent, 'type', 'config')}")
+        print(f"Framework: {getattr(agent, 'framework', 'langchain')}")
+        print(f"Version: {getattr(agent, 'version', '1.0')}")
+
+
+def print_agent_updated(agent) -> None:
+    """Print agent update success with rich formatting.
+
+    Args:
+        agent: The updated agent object
+    """
+    if RICH_AVAILABLE:
+        console = Console()
+        console.print(f"[green]✅ Agent '{agent.name}' updated successfully[/green]")
+    else:
+        print(f"✅ Agent '{agent.name}' updated successfully")
+
+
+def print_agent_deleted(agent_id: str) -> None:
+    """Print agent deletion success with rich formatting.
+
+    Args:
+        agent_id: The deleted agent's ID
+    """
+    if RICH_AVAILABLE:
+        console = Console()
+        console.print(f"[green]✅ Agent deleted successfully (ID: {agent_id})[/green]")
+    else:
+        print(f"✅ Agent deleted successfully (ID: {agent_id})")
+
+
+__all__ = [
+    "RichStreamRenderer",
+    "RunStats",
+    "Step",
+    "StepManager",
+    "RICH_AVAILABLE",
+    "is_uuid",
+    "sanitize_name",
+    "format_file_size",
+    "progress_bar",
+    "print_agent_output",
+    "print_agent_created",
+    "print_agent_updated",
+    "print_agent_deleted",
+]