glaip-sdk 0.0.5b1__py3-none-any.whl → 0.0.6a0__py3-none-any.whl

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
@@ -121,7 +121,7 @@ class Tool(BaseModel):
     tool_file: 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 +185,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 +239,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",
 ]

glaip_sdk/utils/client_utils.py

@@ -9,10 +9,10 @@ Authors:
 """
 
 import logging
-from collections.abc import AsyncGenerator
+from collections.abc import AsyncGenerator, Iterator
 from contextlib import ExitStack
 from pathlib import Path
-from typing import Any, BinaryIO
+from typing import Any, BinaryIO, NoReturn
 
 import httpx
 
@@ -36,14 +36,19 @@ class MultipartData:
         self.files = files
         self._exit_stack = ExitStack()
 
-    def close(self):
+    def close(self) -> None:
         """Close all opened file handles."""
         self._exit_stack.close()
 
-    def __enter__(self):
+    def __enter__(self) -> "MultipartData":
         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:
         self.close()
 
 
@@ -115,12 +120,38 @@ def find_by_name(
     return find_by_name_new(items, name, case_sensitive)
 
 
-def _parse_sse_line(line: str, buf: list, event_type: str = None, event_id: str = None):
-    """Parse a single SSE line and return updated buffer and event metadata."""
-    # Normalize CRLF and treat whitespace-only as blank
-    line = line.rstrip("\r")
+def _handle_blank_line(
+    buf: list[str],
+    event_type: str | None,
+    event_id: str | None,
+) -> tuple[list[str], str | None, str | None, dict[str, Any] | None, bool]:
+    """Handle blank SSE lines by returning accumulated data if buffer exists."""
+    if buf:
+        data = "\n".join(buf)
+        return (
+            [],
+            None,
+            None,
+            {
+                "event": event_type or "message",
+                "id": event_id,
+                "data": data,
+            },
+            False,
+        )
+    return buf, event_type, event_id, None, False
 
-    if not line.strip():  # blank line
+
+def _handle_data_line(
+    line: str,
+    buf: list[str],
+    event_type: str | None,
+    event_id: str | None,
+) -> tuple[list[str], str | None, str | None, dict[str, Any] | None, bool]:
+    """Handle data: lines, including [DONE] sentinel marker."""
+    data_line = line[5:].lstrip()
+
+    if data_line.strip() == "[DONE]":
         if buf:
             data = "\n".join(buf)
             return (
@@ -132,42 +163,59 @@ def _parse_sse_line(line: str, buf: list, event_type: str = None, event_id: str
                     "id": event_id,
                     "data": data,
                 },
-                False,
-            )  # no completion
-        return buf, event_type, event_id, None, False
+                True,
+            )
+        return buf, event_type, event_id, None, True
+
+    buf.append(data_line)
+    return buf, event_type, event_id, None, False
+
+
+def _handle_field_line(
+    line: str,
+    field_type: str,
+    current_value: str | None,
+) -> str | None:
+    """Handle event: or id: field lines."""
+    if field_type == "event":
+        return line[6:].strip() or None
+    elif field_type == "id":
+        return line[3:].strip() or None
+    return current_value
+
+
+def _parse_sse_line(
+    line: str,
+    buf: list[str],
+    event_type: str | None = None,
+    event_id: str | None = None,
+) -> tuple[list[str], str | None, str | None, dict[str, Any] | None, bool]:
+    """Parse a single SSE line and return updated buffer and event metadata."""
+    # Normalize CRLF and treat whitespace-only as blank
+    line = line.rstrip("\r")
+
+    if not line.strip():  # blank line
+        return _handle_blank_line(buf, event_type, event_id)
 
     if line.startswith(":"):  # comment
         return buf, event_type, event_id, None, False
 
     if line.startswith("data:"):
-        data_line = line[5:].lstrip()
-        if data_line.strip() == "[DONE]":  # sentinel end marker
-            if buf:
-                data = "\n".join(buf)
-                return (
-                    [],
-                    None,
-                    None,
-                    {
-                        "event": event_type or "message",
-                        "id": event_id,
-                        "data": data,
-                    },
-                    True,
-                )  # signal completion
-            return buf, event_type, event_id, None, True
-        buf.append(data_line)
-    elif line.startswith("event:"):
-        event_type = line[6:].strip() or None
+        return _handle_data_line(line, buf, event_type, event_id)
+
+    if line.startswith("event:"):
+        event_type = _handle_field_line(line, "event", event_type)
     elif line.startswith("id:"):
-        event_id = line[3:].strip() or None
+        event_id = _handle_field_line(line, "id", event_id)
 
     return buf, event_type, event_id, None, False
 
 
 def _handle_streaming_error(
-    e: Exception, timeout_seconds: float = None, agent_name: str = None
-):
+    e: Exception,
+    timeout_seconds: float | None = None,
+    agent_name: str | None = None,
+) -> NoReturn:
     """Handle different types of streaming errors with appropriate logging and exceptions."""
     if isinstance(e, httpx.ReadTimeout):
         logger.error(f"Read timeout during streaming: {e}")
@@ -199,8 +247,10 @@ def _handle_streaming_error(
 
 
 def iter_sse_events(
-    response: httpx.Response, timeout_seconds: float = None, agent_name: str = None
-):
+    response: httpx.Response,
+    timeout_seconds: float | None = None,
+    agent_name: str | None = None,
+) -> Iterator[dict[str, Any]]:
     """Iterate over Server-Sent Events with proper parsing.
 
     Args:
@@ -316,49 +366,65 @@ def prepare_multipart_data(message: str, files: list[str | BinaryIO]) -> Multipa
         FileNotFoundError: When a file path doesn't exist
         ValueError: When a file object is invalid
     """
+
+    def _prepare_path_entry(
+        path_str: str, stack: ExitStack
+    ) -> tuple[str, tuple[str, BinaryIO, str]]:
+        file_path = Path(path_str)
+        if not file_path.exists():
+            raise FileNotFoundError(f"File not found: {path_str}")
+
+        handle = stack.enter_context(open(file_path, "rb"))
+        return (
+            "files",
+            (
+                file_path.name,
+                handle,
+                "application/octet-stream",
+            ),
+        )
+
+    def _prepare_stream_entry(
+        file_obj: BinaryIO,
+    ) -> tuple[str, tuple[str, BinaryIO, str]]:
+        if not hasattr(file_obj, "read"):
+            raise ValueError(f"Invalid file object: {file_obj}")
+
+        raw_name = getattr(file_obj, "name", "file")
+        filename = Path(raw_name).name if raw_name else "file"
+
+        try:
+            if hasattr(file_obj, "seek"):
+                file_obj.seek(0)
+        except (OSError, ValueError):
+            pass
+
+        return (
+            "files",
+            (
+                filename,
+                file_obj,
+                "application/octet-stream",
+            ),
+        )
+
     # Backend expects 'input' for the main prompt. Keep 'message' for
     # backward-compatibility with any legacy handlers.
     form_data = {"input": message, "message": message, "stream": True}
-    file_list = []
-
-    with ExitStack() as stack:
-        multipart_data = MultipartData(form_data, [])
-        multipart_data._exit_stack = stack
-
-        for file_item in files:
-            if isinstance(file_item, str):
-                # File path - let httpx stream the file handle
-                file_path = Path(file_item)
-                if not file_path.exists():
-                    raise FileNotFoundError(f"File not found: {file_item}")
-
-                # Open file and register for cleanup
-                fh = stack.enter_context(open(file_path, "rb"))
-                file_list.append(
-                    (
-                        "files",
-                        (
-                            file_path.name,
-                            fh,
-                            "application/octet-stream",
-                        ),
-                    )
-                )
+    stack = ExitStack()
+    multipart_data = MultipartData(form_data, [])
+    multipart_data._exit_stack = stack
+
+    try:
+        file_entries = []
+        for item in files:
+            if isinstance(item, str):
+                file_entries.append(_prepare_path_entry(item, stack))
             else:
-                # File-like object
-                if hasattr(file_item, "name"):
-                    filename = getattr(file_item, "name", "file")
-                else:
-                    filename = "file"
-
-                if hasattr(file_item, "read"):
-                    # For file-like objects, we need to read them since httpx expects bytes
-                    file_content = file_item.read()
-                    file_list.append(
-                        ("files", (filename, file_content, "application/octet-stream"))
-                    )
-                else:
-                    raise ValueError(f"Invalid file object: {file_item}")
-
-        multipart_data.files = file_list
+                file_entries.append(_prepare_stream_entry(item))
+
+        multipart_data.files = file_entries
         return multipart_data
+    except Exception:
+        stack.close()
+        raise

glaip_sdk/utils/display.py

@@ -4,6 +4,8 @@ Authors:
     Raymond Christopher (raymond.christopher@gdplabs.id)
 """
 
+from typing import Any
+
 from glaip_sdk.utils.rich_utils import RICH_AVAILABLE
 
 
@@ -34,7 +36,7 @@ def print_agent_output(output: str, title: str = "Agent Output") -> None:
         print("=" * (len(title) + 8))
 
 
-def print_agent_created(agent, title: str = "🤖 Agent Created") -> None:
+def print_agent_created(agent: Any, title: str = "🤖 Agent Created") -> None:
     """Print agent creation success with rich formatting.
 
     Args:
@@ -68,7 +70,7 @@ def print_agent_created(agent, title: str = "🤖 Agent Created") -> None:
         print(f"Version: {getattr(agent, 'version', '1.0')}")
 
 
-def print_agent_updated(agent) -> None:
+def print_agent_updated(agent: Any) -> None:
     """Print agent update success with rich formatting.
 
     Args: