glaip-sdk 0.0.5b1__py3-none-any.whl → 0.0.7__py3-none-any.whl

glaip_sdk/client/base.py

@@ -7,13 +7,14 @@ Authors:
 
 import logging
 import os
-from typing import Any, Union
+from typing import Any, NoReturn, Union
 
 import httpx
 from dotenv import load_dotenv
 
 import glaip_sdk
-from glaip_sdk.config.constants import SDK_NAME, SDK_VERSION
+from glaip_sdk._version import __version__ as SDK_VERSION
+from glaip_sdk.config.constants import SDK_NAME
 from glaip_sdk.exceptions import (
     AuthenticationError,
     ConflictError,
@@ -147,7 +148,7 @@ class BaseClient:
         return self._timeout
 
     @timeout.setter
-    def timeout(self, value: float):
+    def timeout(self, value: float) -> None:
         """Set timeout and rebuild client."""
         self._timeout = value
         if (
@@ -165,10 +166,10 @@ class BaseClient:
         post_endpoint: str,
         get_endpoint_fmt: str,
         *,
-        json=None,
-        data=None,
-        files=None,
-        **kwargs,
+        json: Any | None = None,
+        data: Any | None = None,
+        files: Any | None = None,
+        **kwargs: Any,
     ) -> Any:
         """Helper for POST-then-GET pattern used in create methods.
 
@@ -210,7 +211,7 @@ class BaseClient:
         get_endpoint = get_endpoint_fmt.format(id=resource_id)
         return self._request("GET", get_endpoint)
 
-    def _ensure_client_alive(self):
+    def _ensure_client_alive(self) -> None:
         """Ensure HTTP client is alive, recreate if needed."""
         if not hasattr(self, "http_client") or self.http_client is None:
             if not self._parent_client:
@@ -253,25 +254,25 @@ class BaseClient:
                 client_log.error(f"Retry failed for {method} {endpoint}: {e}")
                 raise e
 
-    def _handle_response(self, response: httpx.Response) -> Any:
-        """Handle HTTP response with proper error handling."""
+    def _parse_response_content(self, response: httpx.Response) -> Any | None:
+        """Parse response content based on content type."""
         if response.status_code == 204:
             return None
 
-        parsed = None
         content_type = response.headers.get("content-type", "").lower()
         if "json" in content_type:
             try:
-                parsed = response.json()
+                return response.json()
             except ValueError:
                 pass
 
-        if parsed is None:
-            if 200 <= response.status_code < 300:
-                return response.text
-            else:
-                self._raise_api_error(response.status_code, response.text)
+        if 200 <= response.status_code < 300:
+            return response.text
+        else:
+            return None  # Let _handle_response deal with error status codes
 
+    def _handle_success_response(self, parsed: Any) -> Any:
+        """Handle successful response with success flag."""
         if isinstance(parsed, dict) and "success" in parsed:
             if parsed.get("success"):
                 return parsed.get("data", parsed)
@@ -279,18 +280,54 @@ class BaseClient:
                 error_type = parsed.get("error", "UnknownError")
                 message = parsed.get("message", "Unknown error")
                 self._raise_api_error(
-                    response.status_code, message, error_type, payload=parsed
+                    400,
+                    message,
+                    error_type,
+                    payload=parsed,  # Using 400 as status since original response had error
                 )
 
-        if 200 <= response.status_code < 300:
-            return parsed
+        return parsed
+
+    def _get_error_message(self, response: httpx.Response) -> str:
+        """Extract error message from response, preferring parsed content."""
+        # Try to get error message from parsed content if available
+        error_message = response.text
+        try:
+            parsed = response.json()
+            if isinstance(parsed, dict) and "message" in parsed:
+                error_message = parsed["message"]
+            elif isinstance(parsed, str):
+                error_message = parsed
+        except (ValueError, TypeError):
+            pass  # Use response.text as fallback
+        return error_message
+
+    def _handle_response(self, response: httpx.Response) -> Any:
+        """Handle HTTP response with proper error handling."""
+        # Handle no-content success before general error handling
+        if response.status_code == 204:
+            return None
 
-        message = parsed.get("message") if isinstance(parsed, dict) else str(parsed)
-        self._raise_api_error(response.status_code, message, payload=parsed)
+        # Handle error status codes
+        if not (200 <= response.status_code < 300):
+            error_message = self._get_error_message(response)
+            self._raise_api_error(response.status_code, error_message)
+            return None  # Won't be reached but helps with type checking
+
+        parsed = self._parse_response_content(response)
+        if parsed is None:
+            return None
+
+        return self._handle_success_response(parsed)
 
     def _raise_api_error(
-        self, status: int, message: str, error_type: str | None = None, *, payload=None
-    ):
+        self,
+        status: int,
+        message: str,
+        error_type: str | None = None,
+        *,
+        payload: Any | None = None,
+    ) -> NoReturn:
         """Raise appropriate exception with rich context."""
         request_id = None
         try:
@@ -324,7 +361,7 @@ class BaseClient:
             request_id=request_id,
         )
 
-    def close(self):
+    def close(self) -> None:
         """Close the HTTP client."""
         if (
             hasattr(self, "http_client")
@@ -334,11 +371,16 @@ class BaseClient:
         ):
             self.http_client.close()
 
-    def __enter__(self):
+    def __enter__(self) -> "BaseClient":
         """Context manager entry."""
         return self
 
-    def __exit__(self, _exc_type, _exc_val, _exc_tb):
+    def __exit__(
+        self,
+        _exc_type: type[BaseException] | None,
+        _exc_val: BaseException | None,
+        _exc_tb: Any,
+    ) -> None:
         """Context manager exit."""
         # Only close if this is not session-scoped
         if not self._session_scoped:

glaip_sdk/client/tools.py

@@ -208,6 +208,44 @@ class ToolClient(BaseClient):
 
         return payload
 
+    def _handle_description_update(
+        self, update_data: dict[str, Any], description: str | None, current_tool: Tool
+    ) -> None:
+        """Handle description field in update payload."""
+        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
+
+    def _handle_tags_update(
+        self, update_data: dict[str, Any], kwargs: dict[str, Any], current_tool: Tool
+    ) -> None:
+        """Handle tags field in update payload."""
+        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)
+
+    def _handle_additional_kwargs(
+        self, update_data: dict[str, Any], kwargs: dict[str, Any]
+    ) -> None:
+        """Handle additional kwargs in update payload."""
+        excluded_keys = {"tags", "framework", "version"}
+        for key, value in kwargs.items():
+            if key not in excluded_keys:
+                update_data[key] = value
+
     def _build_update_payload(
         self,
         current_tool: Tool,
@@ -242,34 +280,14 @@ class ToolClient(BaseClient):
             ),
         }
 
-        # 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 description update
+        self._handle_description_update(update_data, description, current_tool)
 
-        # 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)
+        # Handle tags update
+        self._handle_tags_update(update_data, kwargs, current_tool)
 
-        # 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
+        # Handle additional kwargs
+        self._handle_additional_kwargs(update_data, kwargs)
 
         return update_data
 

glaip_sdk/client/validators.py

@@ -25,8 +25,67 @@ class ResourceValidator:
         """Check if a name is reserved."""
         return name in cls.RESERVED_NAMES
 
+    def _is_uuid_string(self, value: str) -> bool:
+        """Check if a string is a valid UUID."""
+        try:
+            UUID(value)
+            return True
+        except ValueError:
+            return False
+
+    def _resolve_tool_by_name(self, tool_name: str, client: Any) -> str:
+        """Resolve tool name to ID."""
+        found_tools = client.find_tools(name=tool_name)
+        if len(found_tools) == 1:
+            return str(found_tools[0].id)
+        elif len(found_tools) > 1:
+            raise AmbiguousResourceError(
+                f"Multiple tools found with name '{tool_name}': {[t.id for t in found_tools]}"
+            )
+        else:
+            raise NotFoundError(f"Tool not found: {tool_name}")
+
+    def _resolve_tool_by_name_attribute(self, tool: Tool, client: Any) -> str:
+        """Resolve tool by name attribute."""
+        found_tools = client.find_tools(name=tool.name)
+        if len(found_tools) == 1:
+            return str(found_tools[0].id)
+        elif len(found_tools) > 1:
+            raise AmbiguousResourceError(
+                f"Multiple tools found with name '{tool.name}': {[t.id for t in found_tools]}"
+            )
+        else:
+            raise NotFoundError(f"Tool not found: {tool.name}")
+
+    def _process_tool_string(self, tool: str, client: Any) -> str:
+        """Process a string tool reference."""
+        if self._is_uuid_string(tool):
+            return tool  # Already a UUID string
+        else:
+            return self._resolve_tool_by_name(tool, client)
+
+    def _process_tool_object(self, tool: Tool, client: Any) -> str:
+        """Process a Tool object reference."""
+        if hasattr(tool, "id") and tool.id is not None:
+            return str(tool.id)
+        elif isinstance(tool, UUID):
+            return str(tool)
+        elif hasattr(tool, "name") and tool.name is not None:
+            return self._resolve_tool_by_name_attribute(tool, client)
+        else:
+            raise ValidationError(
+                f"Invalid tool reference: {tool} - must have 'id' or 'name' attribute"
+            )
+
+    def _process_single_tool(self, tool: str | Tool, client: Any) -> str:
+        """Process a single tool reference and return its ID."""
+        if isinstance(tool, str):
+            return self._process_tool_string(tool, client)
+        else:
+            return self._process_tool_object(tool, client)
+
     @classmethod
-    def extract_tool_ids(cls, tools: list[str | Tool], client) -> list[str]:
+    def extract_tool_ids(cls, tools: list[str | Tool], client: Any) -> list[str]:
         """Extract tool IDs from a list of tool names, IDs, or Tool objects.
 
         For agent creation, the backend expects tool IDs (UUIDs).
@@ -37,57 +96,81 @@ class ResourceValidator:
         """
         tool_ids = []
         for tool in tools:
-            if isinstance(tool, str):
-                # Check if it's already a UUID
-                try:
-                    UUID(tool)
-                    tool_ids.append(tool)  # Already a UUID string
-                except ValueError:
-                    # It's a name, try to find the tool and get its ID
-                    try:
-                        found_tools = client.find_tools(name=tool)
-                        if len(found_tools) == 1:
-                            tool_ids.append(str(found_tools[0].id))
-                        elif len(found_tools) > 1:
-                            raise AmbiguousResourceError(
-                                f"Multiple tools found with name '{tool}': {[t.id for t in found_tools]}"
-                            )
-                        else:
-                            raise NotFoundError(f"Tool not found: {tool}")
-                    except Exception as e:
-                        raise ValidationError(
-                            f"Failed to resolve tool name '{tool}' to ID: {e}"
-                        )
-            elif hasattr(tool, "id") and tool.id is not None:  # Tool object with ID
-                tool_ids.append(str(tool.id))
-            elif isinstance(tool, UUID):  # UUID object
-                tool_ids.append(str(tool))
-            elif (
-                hasattr(tool, "name") and tool.name is not None
-            ):  # Tool object with name but no ID
-                # Try to find the tool by name and get its ID
-                try:
-                    found_tools = client.find_tools(name=tool.name)
-                    if len(found_tools) == 1:
-                        tool_ids.append(str(found_tools[0].id))
-                    elif len(found_tools) > 1:
-                        raise AmbiguousResourceError(
-                            f"Multiple tools found with name '{tool.name}': {[t.id for t in found_tools]}"
-                        )
-                    else:
-                        raise NotFoundError(f"Tool not found: {tool.name}")
-                except Exception as e:
-                    raise ValidationError(
-                        f"Failed to resolve tool name '{tool.name}' to ID: {e}"
-                    )
-            else:
+            try:
+                tool_id = cls()._process_single_tool(tool, client)
+                tool_ids.append(tool_id)
+            except (AmbiguousResourceError, NotFoundError) as e:
+                # Determine the tool name for the error message
+                tool_name = (
+                    tool if isinstance(tool, str) else getattr(tool, "name", str(tool))
+                )
+                raise ValidationError(
+                    f"Failed to resolve tool name '{tool_name}' to ID: {e}"
+                )
+            except Exception as e:
+                # For other exceptions, wrap them appropriately
+                tool_name = (
+                    tool if isinstance(tool, str) else getattr(tool, "name", str(tool))
+                )
                 raise ValidationError(
-                    f"Invalid tool reference: {tool} - must have 'id' or 'name' attribute"
+                    f"Failed to resolve tool name '{tool_name}' to ID: {e}"
                 )
+
         return tool_ids
 
+    def _resolve_agent_by_name(self, agent_name: str, client: Any) -> str:
+        """Resolve agent name to ID."""
+        found_agents = client.find_agents(name=agent_name)
+        if len(found_agents) == 1:
+            return str(found_agents[0].id)
+        elif len(found_agents) > 1:
+            raise AmbiguousResourceError(
+                f"Multiple agents found with name '{agent_name}': {[a.id for a in found_agents]}"
+            )
+        else:
+            raise NotFoundError(f"Agent not found: {agent_name}")
+
+    def _resolve_agent_by_name_attribute(self, agent: Any, client: Any) -> str:
+        """Resolve agent by name attribute."""
+        found_agents = client.find_agents(name=agent.name)
+        if len(found_agents) == 1:
+            return str(found_agents[0].id)
+        elif len(found_agents) > 1:
+            raise AmbiguousResourceError(
+                f"Multiple agents found with name '{agent.name}': {[a.id for a in found_agents]}"
+            )
+        else:
+            raise NotFoundError(f"Agent not found: {agent.name}")
+
+    def _process_agent_string(self, agent: str, client: Any) -> str:
+        """Process a string agent reference."""
+        if self._is_uuid_string(agent):
+            return agent  # Already a UUID string
+        else:
+            return self._resolve_agent_by_name(agent, client)
+
+    def _process_agent_object(self, agent: Any, client: Any) -> str:
+        """Process an Agent object reference."""
+        if hasattr(agent, "id") and agent.id is not None:
+            return str(agent.id)
+        elif isinstance(agent, UUID):
+            return str(agent)
+        elif hasattr(agent, "name") and agent.name is not None:
+            return self._resolve_agent_by_name_attribute(agent, client)
+        else:
+            raise ValidationError(
+                f"Invalid agent reference: {agent} - must have 'id' or 'name' attribute"
+            )
+
+    def _process_single_agent(self, agent: str | Any, client: Any) -> str:
+        """Process a single agent reference and return its ID."""
+        if isinstance(agent, str):
+            return self._process_agent_string(agent, client)
+        else:
+            return self._process_agent_object(agent, client)
+
     @classmethod
-    def extract_agent_ids(cls, agents: list[str | Any], client) -> list[str]:
+    def extract_agent_ids(cls, agents: list[str | Any], client: Any) -> list[str]:
         """Extract agent IDs from a list of agent names, IDs, or agent objects.
 
         For agent creation, the backend expects agent IDs (UUIDs).
@@ -98,57 +181,34 @@ class ResourceValidator:
         """
         agent_ids = []
         for agent in agents:
-            if isinstance(agent, str):
-                # Check if it's already a UUID
-                try:
-                    UUID(agent)
-                    agent_ids.append(agent)  # Already a UUID string
-                except ValueError:
-                    # It's a name, try to find the agent and get its ID
-                    try:
-                        found_agents = client.find_agents(name=agent)
-                        if len(found_agents) == 1:
-                            agent_ids.append(str(found_agents[0].id))
-                        elif len(found_agents) > 1:
-                            raise AmbiguousResourceError(
-                                f"Multiple agents found with name '{agent}': {[a.id for a in found_agents]}"
-                            )
-                        else:
-                            raise NotFoundError(f"Agent not found: {agent}")
-                    except Exception as e:
-                        raise ValidationError(
-                            f"Failed to resolve agent name '{agent}' to ID: {e}"
-                        )
-            elif hasattr(agent, "id") and agent.id is not None:  # Agent object with ID
-                agent_ids.append(str(agent.id))
-            elif isinstance(agent, UUID):  # UUID object
-                agent_ids.append(str(agent))
-            elif (
-                hasattr(agent, "name") and agent.name is not None
-            ):  # Agent object with name but no ID
-                # Try to find the agent by name and get its ID
-                try:
-                    found_agents = client.find_agents(name=agent.name)
-                    if len(found_agents) == 1:
-                        agent_ids.append(str(found_agents[0].id))
-                    elif len(found_agents) > 1:
-                        raise AmbiguousResourceError(
-                            f"Multiple agents found with name '{agent.name}': {[a.id for a in found_agents]}"
-                        )
-                    else:
-                        raise NotFoundError(f"Agent not found: {agent.name}")
-                except Exception as e:
-                    raise ValidationError(
-                        f"Failed to resolve agent name '{agent.name}' to ID: {e}"
-                    )
-            else:
+            try:
+                agent_id = cls()._process_single_agent(agent, client)
+                agent_ids.append(agent_id)
+            except (AmbiguousResourceError, NotFoundError) as e:
+                # Determine the agent name for the error message
+                agent_name = (
+                    agent
+                    if isinstance(agent, str)
+                    else getattr(agent, "name", str(agent))
+                )
                 raise ValidationError(
-                    f"Invalid agent reference: {agent} - must have 'id' or 'name' attribute"
+                    f"Failed to resolve agent name '{agent_name}' to ID: {e}"
+                )
+            except Exception as e:
+                # For other exceptions, wrap them appropriately
+                agent_name = (
+                    agent
+                    if isinstance(agent, str)
+                    else getattr(agent, "name", str(agent))
                 )
+                raise ValidationError(
+                    f"Failed to resolve agent name '{agent_name}' to ID: {e}"
+                )
+
         return agent_ids
 
     @classmethod
-    def validate_tools_exist(cls, tool_ids: list[str], client) -> None:
+    def validate_tools_exist(cls, tool_ids: list[str], client: Any) -> None:
         """Validate that all tool IDs exist."""
         for tool_id in tool_ids:
             try:
@@ -157,7 +217,7 @@ class ResourceValidator:
                 raise ValidationError(f"Tool not found: {tool_id}")
 
     @classmethod
-    def validate_agents_exist(cls, agent_ids: list[str], client) -> None:
+    def validate_agents_exist(cls, agent_ids: list[str], client: Any) -> None:
         """Validate that all agent IDs exist."""
         for agent_id in agent_ids:
             try:

glaip_sdk/config/constants.py

@@ -13,9 +13,7 @@ DEFAULT_TIMEOUT = 30.0
 DEFAULT_AGENT_RUN_TIMEOUT = 300
 
 # User agent and version
-
 SDK_NAME = "glaip-sdk"
-SDK_VERSION = "0.1.0"
 
 # Reserved names that cannot be used for agents/tools
 RESERVED_NAMES = {

glaip_sdk/models.py

@@ -39,7 +39,7 @@ class Agent(BaseModel):
     updated_at: datetime | None = None  # Backend returns last update timestamp
     _client: Any = None
 
-    def _set_client(self, client):
+    def _set_client(self, client: Any) -> "Agent":
         """Set the client reference for this resource."""
         self._client = client
         return self
@@ -119,9 +119,10 @@ class Tool(BaseModel):
     version: str | None = None
     tool_script: str | None = None
     tool_file: str | None = None
+    tags: str | list[str] | None = None
     _client: Any = None  # Will hold client reference
 
-    def _set_client(self, client):
+    def _set_client(self, client: Any) -> "Tool":
         """Set the client reference for this resource."""
         self._client = client
         return self
@@ -185,7 +186,7 @@ class MCP(BaseModel):
     metadata: dict[str, Any] | None = None
     _client: Any = None  # Will hold client reference
 
-    def _set_client(self, client):
+    def _set_client(self, client: Any) -> "MCP":
         """Set the client reference for this resource."""
         self._client = client
         return self
@@ -239,7 +240,7 @@ class TTYRenderer:
     def __init__(self, use_color: bool = True):
         self.use_color = use_color
 
-    def render_message(self, message: str, event_type: str = "message"):
+    def render_message(self, message: str, event_type: str = "message") -> None:
         """Render a message with optional color."""
         if event_type == "error":
             print(f"ERROR: {message}", flush=True)

glaip_sdk/utils/__init__.py

@@ -23,18 +23,18 @@ from glaip_sdk.utils.rich_utils import RICH_AVAILABLE
 from glaip_sdk.utils.run_renderer import RichStreamRenderer
 
 __all__ = [
+    "RICH_AVAILABLE",
     "RichStreamRenderer",
     "RunStats",
     "Step",
     "StepManager",
-    "RICH_AVAILABLE",
-    "is_uuid",
-    "sanitize_name",
-    "format_file_size",
     "format_datetime",
-    "progress_bar",
-    "print_agent_output",
+    "format_file_size",
+    "is_uuid",
     "print_agent_created",
-    "print_agent_updated",
     "print_agent_deleted",
+    "print_agent_output",
+    "print_agent_updated",
+    "progress_bar",
+    "sanitize_name",
 ]