glaip-sdk 0.0.6a0__py3-none-any.whl → 0.0.7__py3-none-any.whl

glaip_sdk/client/agents.py

@@ -42,6 +42,9 @@ from glaip_sdk.utils.validation import validate_agent_instruction
 # API endpoints
 AGENTS_ENDPOINT = "/agents/"
 
+# SSE content type
+SSE_CONTENT_TYPE = "text/event-stream"
+
 # Set up module-level logger
 logger = logging.getLogger("glaip_sdk.agents")
 
@@ -519,7 +522,7 @@ class AgentClient(BaseClient):
         Returns:
             Tuple of (payload, data_payload, files_payload, headers, multipart_data)
         """
-        headers = {"Accept": "text/event-stream"}
+        headers = {"Accept": SSE_CONTENT_TYPE}
 
         if files:
             # Handle multipart data for file uploads
@@ -665,10 +668,6 @@ class AgentClient(BaseClient):
             return content
         return final_text
 
-    def _handle_final_response_event(self, ev: dict[str, Any]) -> str:
-        """Handle final response events."""
-        return ev.get("content", "")
-
     def _handle_usage_event(
         self, ev: dict[str, Any], stats_usage: dict[str, Any]
     ) -> None:
@@ -708,11 +707,11 @@ class AgentClient(BaseClient):
         if kind == "artifact":
             return final_text, stats_usage
 
-        # Accumulate assistant content
-        if ev.get("content"):
+        # Handle different event types
+        if kind == "final_response" and ev.get("content"):
+            final_text = ev.get("content", "")
+        elif ev.get("content"):
             final_text = self._handle_content_event(ev, final_text)
-        elif kind == "final_response" and ev.get("content"):
-            final_text = self._handle_final_response_event(ev)
         elif kind == "usage":
             self._handle_usage_event(ev, stats_usage)
         elif kind == "run_info":
@@ -844,6 +843,75 @@ class AgentClient(BaseClient):
         r.on_complete(st)
         return final_payload
 
+    def _prepare_request_data(
+        self,
+        message: str,
+        files: list[str | BinaryIO] | None,
+        **kwargs,
+    ) -> tuple[dict | None, dict | None, dict | None, dict | None]:
+        """Prepare request data for async agent runs.
+
+        Returns:
+            Tuple of (payload, data_payload, files_payload, headers)
+        """
+        if files:
+            # Handle multipart data for file uploads
+            multipart_data = prepare_multipart_data(message, files)
+            # Inject optional multipart extras expected by backend
+            if "chat_history" in kwargs and kwargs["chat_history"] is not None:
+                multipart_data.data["chat_history"] = kwargs["chat_history"]
+            if "pii_mapping" in kwargs and kwargs["pii_mapping"] is not None:
+                multipart_data.data["pii_mapping"] = kwargs["pii_mapping"]
+
+            headers = {"Accept": SSE_CONTENT_TYPE}
+            return None, multipart_data.data, multipart_data.files, headers
+        else:
+            # Simple JSON payload for text-only requests
+            payload = {"input": message, "stream": True, **kwargs}
+            headers = {"Accept": SSE_CONTENT_TYPE}
+            return payload, None, None, headers
+
+    def _create_async_client_config(
+        self, timeout: float | None, headers: dict | None
+    ) -> dict:
+        """Create async client configuration with proper headers and timeout."""
+        config = self._build_async_client(timeout or self.timeout)
+        if headers:
+            config["headers"] = {**config["headers"], **headers}
+        return config
+
+    async def _stream_agent_response(
+        self,
+        async_client: httpx.AsyncClient,
+        agent_id: str,
+        payload: dict | None,
+        data_payload: dict | None,
+        files_payload: dict | None,
+        headers: dict | None,
+        timeout_seconds: float,
+        agent_name: str | None,
+    ) -> AsyncGenerator[dict, None]:
+        """Stream the agent response and yield parsed JSON chunks."""
+        async with async_client.stream(
+            "POST",
+            f"/agents/{agent_id}/run",
+            json=payload,
+            data=data_payload,
+            files=files_payload,
+            headers=headers,
+        ) as stream_response:
+            stream_response.raise_for_status()
+
+            async for event in aiter_sse_events(
+                stream_response, timeout_seconds, agent_name
+            ):
+                try:
+                    chunk = json.loads(event["data"])
+                    yield chunk
+                except json.JSONDecodeError:
+                    logger.debug("Non-JSON SSE fragment skipped")
+                    continue
+
     async def arun_agent(
         self,
         agent_id: str,
@@ -870,74 +938,34 @@ class AgentClient(BaseClient):
             httpx.TimeoutException: When general timeout occurs
             Exception: For other unexpected errors
         """
-        # Prepare multipart data if files are provided
-        multipart_data = None
-        headers = None  # None means "don't override client defaults"
-
-        if files:
-            multipart_data = prepare_multipart_data(message, files)
-            # Inject optional multipart extras expected by backend
-            if "chat_history" in kwargs and kwargs["chat_history"] is not None:
-                multipart_data.data["chat_history"] = kwargs["chat_history"]
-            if "pii_mapping" in kwargs and kwargs["pii_mapping"] is not None:
-                multipart_data.data["pii_mapping"] = kwargs["pii_mapping"]
-            headers = None  # Let httpx set proper multipart boundaries
+        # Prepare request data
+        payload, data_payload, files_payload, headers = self._prepare_request_data(
+            message, files, **kwargs
+        )
 
-        # When streaming, explicitly prefer SSE
-        headers = {**(headers or {}), "Accept": "text/event-stream"}
+        # Create async client configuration
+        async_client_config = self._create_async_client_config(timeout, headers)
 
-        if files:
-            payload = None
-            # Use multipart data
-            data_payload = multipart_data.data
-            files_payload = multipart_data.files
-        else:
-            payload = {"input": message, **kwargs}
-            # Explicitly send stream intent both ways
-            payload["stream"] = True
-            data_payload = None
-            files_payload = None
-
-        # Use timeout from parameter or instance default
-        request_timeout = timeout or self.timeout
+        # Get execution timeout for streaming control
+        timeout_seconds = kwargs.get("timeout", DEFAULT_AGENT_RUN_TIMEOUT)
+        agent_name = kwargs.get("agent_name")
 
         try:
-            async_client_config = self._build_async_client(request_timeout)
-            if headers:
-                async_client_config["headers"] = {
-                    **async_client_config["headers"],
-                    **headers,
-                }
-
-            # Create async client for this request
+            # Create async client and stream response
             async with httpx.AsyncClient(**async_client_config) as async_client:
-                async with async_client.stream(
-                    "POST",
-                    f"/agents/{agent_id}/run",
-                    json=payload,
-                    data=data_payload,
-                    files=files_payload,
-                    headers=headers,
-                ) as stream_response:
-                    stream_response.raise_for_status()
-
-                    # Get agent run timeout for execution control
-                    # Prefer parameter timeout, otherwise use default
-                    timeout_seconds = kwargs.get("timeout", DEFAULT_AGENT_RUN_TIMEOUT)
-
-                    agent_name = kwargs.get("agent_name")
-
-                    async for event in aiter_sse_events(
-                        stream_response, timeout_seconds, agent_name
-                    ):
-                        try:
-                            chunk = json.loads(event["data"])
-                            yield chunk
-                        except json.JSONDecodeError:
-                            logger.debug("Non-JSON SSE fragment skipped")
-                            continue
+                async for chunk in self._stream_agent_response(
+                    async_client,
+                    agent_id,
+                    payload,
+                    data_payload,
+                    files_payload,
+                    headers,
+                    timeout_seconds,
+                    agent_name,
+                ):
+                    yield chunk
 
         finally:
-            # Ensure we close any opened file handles from multipart
-            if multipart_data:
-                multipart_data.close()
+            # Ensure cleanup - this is handled by the calling context
+            # but we keep this for safety in case of future changes
+            pass

glaip_sdk/client/base.py

@@ -254,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)
@@ -280,14 +280,45 @@ 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
+
+        # 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
 
-        message = parsed.get("message") if isinstance(parsed, dict) else str(parsed)
-        self._raise_api_error(response.status_code, message, payload=parsed)
+        return self._handle_success_response(parsed)
 
     def _raise_api_error(
         self,

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/models.py

@@ -119,6 +119,7 @@ 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: Any) -> "Tool":

glaip_sdk/utils/client_utils.py

@@ -246,6 +246,33 @@ def _handle_streaming_error(
         raise
 
 
+def _process_sse_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]:
+    """Process a single SSE line and return updated state."""
+    result = _parse_sse_line(line, buf, event_type, event_id)
+    buf, event_type, event_id, event_data, completed = result
+    return buf, event_type, event_id, event_data, completed
+
+
+def _yield_event_data(event_data: dict[str, Any] | None) -> Iterator[dict[str, Any]]:
+    """Yield event data if available."""
+    if event_data:
+        yield event_data
+
+
+def _flush_remaining_buffer(
+    buf: list[str], event_type: str | None, event_id: str | None
+) -> Iterator[dict[str, Any]]:
+    """Flush any remaining data in buffer."""
+    if buf:
+        yield {
+            "event": event_type or "message",
+            "id": event_id,
+            "data": "\n".join(buf),
+        }
+
+
 def iter_sse_events(
     response: httpx.Response,
     timeout_seconds: float | None = None,
@@ -276,25 +303,16 @@ def iter_sse_events(
             if line is None:
                 continue
 
-            result = _parse_sse_line(line, buf, event_type, event_id)
-            if len(result) == 5:  # completion signal included
-                buf, event_type, event_id, event_data, completed = result
-            else:  # normal case
-                buf, event_type, event_id, event_data = result
-                completed = False
+            buf, event_type, event_id, event_data, completed = _process_sse_line(
+                line, buf, event_type, event_id
+            )
 
-            if event_data:
-                yield event_data
+            yield from _yield_event_data(event_data)
             if completed:
                 return
 
         # Flush any remaining data
-        if buf:
-            yield {
-                "event": event_type or "message",
-                "id": event_id,
-                "data": "\n".join(buf),
-            }
+        yield from _flush_remaining_buffer(buf, event_type, event_id)
 
     except Exception as e:
         _handle_streaming_error(e, timeout_seconds, agent_name)
@@ -329,11 +347,7 @@ async def aiter_sse_events(
                 continue
 
             result = _parse_sse_line(line, buf, event_type, event_id)
-            if len(result) == 5:  # completion signal included
-                buf, event_type, event_id, event_data, completed = result
-            else:  # normal case
-                buf, event_type, event_id, event_data = result
-                completed = False
+            buf, event_type, event_id, event_data, completed = result
 
             if event_data:
                 yield event_data
@@ -352,6 +366,66 @@ async def aiter_sse_events(
         _handle_streaming_error(e, timeout_seconds, agent_name)
 
 
+def _create_form_data(message: str) -> dict[str, Any]:
+    """Create form data with message and stream flag."""
+    return {"input": message, "message": message, "stream": True}
+
+
+def _prepare_file_entry(
+    item: str | BinaryIO, stack: ExitStack
+) -> tuple[str, tuple[str, BinaryIO, str]]:
+    """Prepare a single file entry for multipart data."""
+    if isinstance(item, str):
+        return _prepare_path_entry(item, stack)
+    else:
+        return _prepare_stream_entry(item)
+
+
+def _prepare_path_entry(
+    path_str: str, stack: ExitStack
+) -> tuple[str, tuple[str, BinaryIO, str]]:
+    """Prepare a file path entry."""
+    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]]:
+    """Prepare a file object entry."""
+    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",
+        ),
+    )
+
+
 def prepare_multipart_data(message: str, files: list[str | BinaryIO]) -> MultipartData:
     """Prepare multipart form data for file uploads.
 
@@ -366,63 +440,13 @@ 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}
+    form_data = _create_form_data(message)
     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_entries.append(_prepare_stream_entry(item))
-
+        file_entries = [_prepare_file_entry(item, stack) for item in files]
         multipart_data.files = file_entries
         return multipart_data
     except Exception:

glaip_sdk/utils/import_export.py

@@ -40,7 +40,9 @@ def extract_ids_from_export(items: list[Any]) -> list[str]:
     return ids
 
 
-def convert_export_to_import_format(data: dict[str, Any]) -> dict[str, Any]:
+def convert_export_to_import_format(
+    data: dict[str, Any],
+) -> dict[str, Any]:
     """Convert export format to import-compatible format (extract IDs from objects).
 
     Args: