glaip-sdk 0.0.4__py3-none-any.whl → 0.0.5b1__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,20 +43,27 @@ 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)
 
@@ -101,7 +119,7 @@ class ToolClient(BaseClient):
             data["description"] = description
 
         # Handle tags if provided in kwargs
-        if "tags" in kwargs and kwargs["tags"]:
+        if kwargs.get("tags"):
             if isinstance(kwargs["tags"], list):
                 data["tags"] = ",".join(kwargs["tags"])
             else:
@@ -131,13 +149,130 @@ class ToolClient(BaseClient):
 
             response = self._request(
                 "POST",
-                "/tools/upload",
+                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,
@@ -279,12 +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}")
+        self._request("DELETE", f"{TOOLS_ENDPOINT}{tool_id}")
 
     def get_tool_script(self, tool_id: str) -> str:
         """Get the tool script content.
@@ -299,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}")
@@ -336,7 +471,7 @@ class ToolClient(BaseClient):
 
                 response = self._request(
                     "PUT",
-                    f"/tools/{tool_id}/upload",
+                    TOOLS_UPLOAD_BY_ID_ENDPOINT_FMT.format(tool_id=tool_id),
                     files=files,
                     data=kwargs,  # Pass kwargs directly as data
                 )

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):

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"]

glaip_sdk/utils/__init__.py

@@ -4,177 +4,23 @@ Authors:
     Raymond Christopher (raymond.christopher@gdplabs.id)
 """
 
-import re
-from uuid import UUID
-
-import click
-
-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:
-    """Check if a string is a valid UUID.
-
-    Args:
-        value: String to check
-
-    Returns:
-        True if value is a valid UUID, False otherwise
-    """
-    try:
-        UUID(value)
-        return True
-    except (ValueError, TypeError):
-        return False
-
-
-def sanitize_name(name: str) -> str:
-    """Sanitize a name for resource creation.
-
-    Args:
-        name: Raw name input
-
-    Returns:
-        Sanitized name suitable for resource creation
-    """
-    # Remove special characters and normalize
-    sanitized = re.sub(r"[^a-zA-Z0-9\-_]", "-", name.strip())
-    sanitized = re.sub(r"-+", "-", sanitized)  # Collapse multiple dashes
-    return sanitized.lower().strip("-")
-
-
-def format_file_size(size_bytes: int) -> str:
-    """Format file size in human readable format.
-
-    Args:
-        size_bytes: Size in bytes
-
-    Returns:
-        Human readable size string (e.g., "1.5 MB")
-    """
-    for unit in ["B", "KB", "MB", "GB"]:
-        if size_bytes < 1024.0:
-            return f"{size_bytes:.1f} {unit}"
-        size_bytes /= 1024.0
-    return f"{size_bytes:.1f} TB"
-
-
-def progress_bar(iterable, description: str = "Processing"):
-    """Simple progress bar using click.
-
-    Args:
-        iterable: Iterable to process
-        description: Progress description
-
-    Yields:
-        Items from iterable with progress display
-    """
-    try:
-        with click.progressbar(iterable, label=description) as bar:
-            for item in bar:
-                yield item
-    except ImportError:
-        # 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})")
-
+from glaip_sdk.utils.display import (
+    print_agent_created,
+    print_agent_deleted,
+    print_agent_output,
+    print_agent_updated,
+)
+from glaip_sdk.utils.general import (
+    format_datetime,
+    format_file_size,
+    is_uuid,
+    progress_bar,
+    sanitize_name,
+)
+from glaip_sdk.utils.rendering.models import RunStats, Step
+from glaip_sdk.utils.rendering.steps import StepManager
+from glaip_sdk.utils.rich_utils import RICH_AVAILABLE
+from glaip_sdk.utils.run_renderer import RichStreamRenderer
 
 __all__ = [
     "RichStreamRenderer",
@@ -185,6 +31,7 @@ __all__ = [
     "is_uuid",
     "sanitize_name",
     "format_file_size",
+    "format_datetime",
     "progress_bar",
     "print_agent_output",
     "print_agent_created",