glaip-sdk 0.0.20__py3-none-any.whl → 0.1.3__py3-none-any.whl

glaip_sdk/client/_agent_payloads.py

@@ -348,9 +348,7 @@ class AgentCreateRequest:
             payload["tool_configs"] = _copy_structure(self.tool_configs)
 
         effective_agent_config = _sanitize_agent_config(self.agent_config)
-        effective_agent_config = _merge_execution_timeout(
-            effective_agent_config, self.timeout
-        )
+        effective_agent_config = _merge_execution_timeout(effective_agent_config, self.timeout)
         if effective_agent_config:
             payload["agent_config"] = effective_agent_config
 
@@ -407,31 +405,19 @@ __all__ = [
 ]
 
 
-def _build_base_update_payload(
-    request: AgentUpdateRequest, current_agent: Any
-) -> dict[str, Any]:
+def _build_base_update_payload(request: AgentUpdateRequest, current_agent: Any) -> dict[str, Any]:
     return {
-        "name": request.name.strip()
-        if request.name is not None
-        else getattr(current_agent, "name", None),
+        "name": request.name.strip() if request.name is not None else getattr(current_agent, "name", None),
         "instruction": request.instruction.strip()
         if request.instruction is not None
         else getattr(current_agent, "instruction", None),
-        "type": request.agent_type
-        or getattr(current_agent, "type", None)
-        or DEFAULT_AGENT_TYPE,
-        "framework": request.framework
-        or getattr(current_agent, "framework", None)
-        or DEFAULT_AGENT_FRAMEWORK,
-        "version": request.version
-        or getattr(current_agent, "version", None)
-        or DEFAULT_AGENT_VERSION,
+        "type": request.agent_type or getattr(current_agent, "type", None) or DEFAULT_AGENT_TYPE,
+        "framework": request.framework or getattr(current_agent, "framework", None) or DEFAULT_AGENT_FRAMEWORK,
+        "version": request.version or getattr(current_agent, "version", None) or DEFAULT_AGENT_VERSION,
     }
 
 
-def _resolve_update_language_model_fields(
-    request: AgentUpdateRequest, current_agent: Any
-) -> dict[str, Any]:
+def _resolve_update_language_model_fields(request: AgentUpdateRequest, current_agent: Any) -> dict[str, Any]:
     fields = resolve_language_model_fields(
         model=request.model,
         language_model_id=request.language_model_id,
@@ -443,9 +429,7 @@ def _resolve_update_language_model_fields(
     return fields
 
 
-def _collect_optional_update_fields(
-    request: AgentUpdateRequest, current_agent: Any
-) -> dict[str, Any]:
+def _collect_optional_update_fields(request: AgentUpdateRequest, current_agent: Any) -> dict[str, Any]:
     result: dict[str, Any] = {}
 
     for field_name, value in (
@@ -483,9 +467,7 @@ def _collect_optional_update_fields(
     return result
 
 
-def _collect_relationship_fields(
-    request: AgentUpdateRequest, current_agent: Any
-) -> dict[str, Any]:
+def _collect_relationship_fields(request: AgentUpdateRequest, current_agent: Any) -> dict[str, Any]:
     return {
         "tools": _resolve_relation_ids(request.tools, current_agent, "tools"),
         "agents": _resolve_relation_ids(request.agents, current_agent, "agents"),
@@ -493,9 +475,7 @@ def _collect_relationship_fields(
     }
 
 
-def _resolve_agent_config_update(
-    request: AgentUpdateRequest, current_agent: Any
-) -> dict[str, Any] | None:
+def _resolve_agent_config_update(request: AgentUpdateRequest, current_agent: Any) -> dict[str, Any] | None:
     effective_agent_config = _sanitize_agent_config(request.agent_config)
     if effective_agent_config is not None:
         return effective_agent_config

glaip_sdk/client/agents.py

@@ -34,7 +34,7 @@ from glaip_sdk.config.constants import (
     DEFAULT_AGENT_VERSION,
     DEFAULT_MODEL,
 )
-from glaip_sdk.exceptions import NotFoundError
+from glaip_sdk.exceptions import NotFoundError, ValidationError
 from glaip_sdk.models import Agent
 from glaip_sdk.payload_schemas.agent import list_server_only_fields
 from glaip_sdk.utils.agent_config import normalize_agent_config_for_import
@@ -97,9 +97,7 @@ def _merge_override_maps(
         for key, value in source.items():
             if value is None:
                 continue
-            merged[key] = (
-                _normalise_sequence(value) if key in _MERGED_SEQUENCE_FIELDS else value
-            )
+            merged[key] = _normalise_sequence(value) if key in _MERGED_SEQUENCE_FIELDS else value
     return merged
 
 
@@ -134,9 +132,7 @@ def _prepare_agent_metadata(value: Any) -> dict[str, Any]:
     return prepared
 
 
-def _load_agent_file_payload(
-    file_path: Path, *, model_override: str | None
-) -> dict[str, Any]:
+def _load_agent_file_payload(file_path: Path, *, model_override: str | None) -> dict[str, Any]:
     """Load agent configuration from disk and normalise legacy fields."""
     if not file_path.exists():
         raise FileNotFoundError(f"Agent configuration file not found: {file_path}")
@@ -168,9 +164,7 @@ def _prepare_import_payload(
     raw_definition = load_resource_from_file(file_path)
     original_refs = _extract_original_refs(raw_definition)
 
-    base_payload = _load_agent_file_payload(
-        file_path, model_override=overrides_dict.get("model")
-    )
+    base_payload = _load_agent_file_payload(file_path, model_override=overrides_dict.get("model"))
 
     cli_args = _build_cli_args(overrides_dict)
 
@@ -223,11 +217,7 @@ def _build_cli_args(overrides_dict: dict) -> dict[str, Any]:
 
 def _build_additional_args(overrides_dict: dict, cli_args: dict) -> dict[str, Any]:
     """Build additional args not already in CLI args."""
-    return {
-        key: value
-        for key, value in overrides_dict.items()
-        if value is not None and key not in cli_args
-    }
+    return {key: value for key, value in overrides_dict.items() if value is not None and key not in cli_args}
 
 
 def _remove_model_fields_if_needed(merged: dict, overrides_dict: dict) -> None:
@@ -278,9 +268,7 @@ class AgentClient(BaseClient):
         """
         if query is not None and kwargs:
             # Both query object and individual parameters provided
-            raise ValueError(
-                "Provide either `query` or individual filter arguments, not both."
-            )
+            raise ValueError("Provide either `query` or individual filter arguments, not both.")
 
         if query is None:
             # Create query from individual parameters for backward compatibility
@@ -339,7 +327,19 @@ class AgentClient(BaseClient):
 
     def get_agent_by_id(self, agent_id: str) -> Agent:
         """Get agent by ID."""
-        data = self._request("GET", f"/agents/{agent_id}")
+        try:
+            data = self._request("GET", f"/agents/{agent_id}")
+        except ValidationError as exc:
+            if exc.status_code == 422:
+                message = f"Agent '{agent_id}' not found"
+                raise NotFoundError(
+                    message,
+                    status_code=404,
+                    error_type=exc.error_type,
+                    payload=exc.payload,
+                    request_id=exc.request_id,
+                ) from exc
+            raise
 
         if isinstance(data, str):
             # Some backends may respond with plain text for missing agents.
@@ -372,9 +372,7 @@ class AgentClient(BaseClient):
             self._renderer_manager = manager
         return manager
 
-    def _create_renderer(
-        self, renderer: RichStreamRenderer | str | None, **kwargs: Any
-    ) -> RichStreamRenderer:
+    def _create_renderer(self, renderer: RichStreamRenderer | str | None, **kwargs: Any) -> RichStreamRenderer:
         manager = self._get_renderer_manager()
         verbose = kwargs.get("verbose", False)
         if isinstance(renderer, RichStreamRenderer) or hasattr(renderer, "on_start"):
@@ -506,9 +504,7 @@ class AgentClient(BaseClient):
             return entry_id
 
         if entry_name:
-            resolved, success = self._resolve_resource_by_name(
-                find_by_name, entry_name, singular, plural
-            )
+            resolved, success = self._resolve_resource_by_name(find_by_name, entry_name, singular, plural)
             return resolved if success else entry_name
 
         raise ValueError(f"{singular} references must include a valid ID or name.")
@@ -523,9 +519,7 @@ class AgentClient(BaseClient):
         return str(entry)
 
     @staticmethod
-    def _validate_resource_id(
-        fetch_by_id: Callable[[str], Any], candidate_id: str | None
-    ) -> str | None:
+    def _validate_resource_id(fetch_by_id: Callable[[str], Any], candidate_id: str | None) -> str | None:
         if not candidate_id:
             return None
         try:
@@ -547,21 +541,13 @@ class AgentClient(BaseClient):
             return entry_name, False
 
         if not matches:
-            raise ValueError(
-                f"{singular} '{entry_name}' not found in current workspace."
-            )
+            raise ValueError(f"{singular} '{entry_name}' not found in current workspace.")
         if len(matches) > 1:
-            exact = [
-                m
-                for m in matches
-                if getattr(m, "name", "").lower() == entry_name.lower()
-            ]
+            exact = [m for m in matches if getattr(m, "name", "").lower() == entry_name.lower()]
             if len(exact) == 1:
                 matches = exact
             else:
-                raise ValueError(
-                    f"Multiple {plural} named '{entry_name}'. Please disambiguate."
-                )
+                raise ValueError(f"Multiple {plural} named '{entry_name}'. Please disambiguate.")
         return str(matches[0].id), True
 
     def _resolve_tool_ids(
@@ -610,9 +596,7 @@ class AgentClient(BaseClient):
 
     def _create_agent_from_payload(self, payload: Mapping[str, Any]) -> "Agent":
         """Create an agent using a fully prepared payload mapping."""
-        known, extras = _split_known_and_extra(
-            payload, AgentCreateRequest.__dataclass_fields__
-        )
+        known, extras = _split_known_and_extra(payload, AgentCreateRequest.__dataclass_fields__)
 
         name = known.pop("name", None)
         instruction = known.pop("instruction", None)
@@ -721,9 +705,7 @@ class AgentClient(BaseClient):
         overrides = _merge_override_maps(base_overrides, kwargs)
 
         if file is not None:
-            payload = _prepare_import_payload(
-                Path(file).expanduser(), overrides, drop_model_fields=True
-            )
+            payload = _prepare_import_payload(Path(file).expanduser(), overrides, drop_model_fields=True)
             if overrides.get("model") is None:
                 payload.pop("model", None)
         else:
@@ -746,9 +728,7 @@ class AgentClient(BaseClient):
         payload: Mapping[str, Any],
     ) -> "Agent":
         """Update an agent using a prepared payload mapping."""
-        known, extras = _split_known_and_extra(
-            payload, AgentUpdateRequest.__dataclass_fields__
-        )
+        known, extras = _split_known_and_extra(payload, AgentUpdateRequest.__dataclass_fields__)
         _normalise_sequence_fields(known)
 
         tool_refs = extras.pop("_tool_refs", None)
@@ -818,9 +798,7 @@ class AgentClient(BaseClient):
         overrides = _merge_override_maps(base_overrides, kwargs)
 
         if file is not None:
-            payload = _prepare_import_payload(
-                Path(file).expanduser(), overrides, drop_model_fields=True
-            )
+            payload = _prepare_import_payload(Path(file).expanduser(), overrides, drop_model_fields=True)
         else:
             payload = overrides
 
@@ -882,9 +860,7 @@ class AgentClient(BaseClient):
                 payload["tty"] = True
             return payload, None, None, headers, None
 
-    def _get_timeout_values(
-        self, timeout: float | None, **kwargs: Any
-    ) -> tuple[float, float]:
+    def _get_timeout_values(self, timeout: float | None, **kwargs: Any) -> tuple[float, float]:
         """Get request timeout and execution timeout values.
 
         Args:
@@ -1009,9 +985,7 @@ class AgentClient(BaseClient):
             headers = {"Accept": SSE_CONTENT_TYPE}
             return payload, None, None, headers
 
-    def _create_async_client_config(
-        self, timeout: float | None, headers: dict | None
-    ) -> dict:
+    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:
@@ -1040,9 +1014,7 @@ class AgentClient(BaseClient):
         ) as stream_response:
             stream_response.raise_for_status()
 
-            async for event in aiter_sse_events(
-                stream_response, timeout_seconds, agent_name
-            ):
+            async for event in aiter_sse_events(stream_response, timeout_seconds, agent_name):
                 try:
                     chunk = json.loads(event["data"])
                     yield chunk
@@ -1077,9 +1049,7 @@ class AgentClient(BaseClient):
             Exception: For other unexpected errors
         """
         # Prepare request data
-        payload, data_payload, files_payload, headers = self._prepare_request_data(
-            message, files, **kwargs
-        )
+        payload, data_payload, files_payload, headers = self._prepare_request_data(message, files, **kwargs)
 
         # Create async client configuration
         async_client_config = self._create_async_client_config(timeout, headers)

glaip_sdk/client/base.py

@@ -7,6 +7,7 @@ Authors:
 
 import logging
 import os
+from collections.abc import Iterable, Mapping
 from typing import Any, NoReturn, Union
 
 import httpx
@@ -151,12 +152,7 @@ class BaseClient:
     def timeout(self, value: float) -> None:
         """Set timeout and rebuild client."""
         self._timeout = value
-        if (
-            hasattr(self, "http_client")
-            and self.http_client
-            and not self._session_scoped
-            and not self._parent_client
-        ):
+        if hasattr(self, "http_client") and self.http_client and not self._session_scoped and not self._parent_client:
             self.http_client.close()
             self.http_client = self._build_client(value)
 
@@ -246,18 +242,14 @@ class BaseClient:
             client_log.debug(f"Response status: {response.status_code}")
             return response
         except httpx.ConnectError as e:
-            client_log.warning(
-                f"Connection error on {method} {endpoint}, retrying once: {e}"
-            )
+            client_log.warning(f"Connection error on {method} {endpoint}, retrying once: {e}")
             try:
                 response = self.http_client.request(method, endpoint, **kwargs)
-                client_log.debug(
-                    f"Retry successful, response status: {response.status_code}"
-                )
+                client_log.debug(f"Retry successful, response status: {response.status_code}")
                 return response
             except httpx.ConnectError:
                 client_log.error(f"Retry failed for {method} {endpoint}: {e}")
-                raise e
+                raise
 
     def _request(self, method: str, endpoint: str, **kwargs) -> Any:
         """Make HTTP request with error handling and unwrap success envelopes."""
@@ -298,7 +290,7 @@ class BaseClient:
                 return parsed.get("data", parsed) if unwrap else parsed
             else:
                 error_type = parsed.get("error", "UnknownError")
-                message = parsed.get("message", DEFAULT_ERROR_MESSAGE)
+                message = self._format_error_dict({key: value for key, value in parsed.items() if key != "success"})
                 self._raise_api_error(
                     400,
                     message,
@@ -341,12 +333,58 @@ class BaseClient:
                 return validation_message
             return f"Validation error: {parsed}"
 
+        formatted_details = None
+        if "details" in parsed:
+            formatted_details = self._format_error_details(parsed["details"])
+
         message = parsed.get("message")
         if message:
+            if formatted_details:
+                return f"{message}\n{formatted_details}"
             return message
 
+        if formatted_details:
+            return formatted_details
+
         return str(parsed) if parsed else DEFAULT_ERROR_MESSAGE
 
+    def _format_error_details(self, details: Any) -> str | None:
+        """Render generic error details into a human-readable string."""
+        if details is None:
+            return None
+
+        if isinstance(details, dict):
+            return self._format_detail_mapping(details)
+
+        if isinstance(details, (list, tuple, set)):
+            return self._format_detail_iterable(details)
+
+        return f"Details: {details}"
+
+    @staticmethod
+    def _format_detail_mapping(details: Mapping[str, Any]) -> str | None:
+        """Format details provided as a mapping."""
+        entries = [f"  {key}: {value}" for key, value in details.items()]
+        if not entries:
+            return None
+        return "Details:\n" + "\n".join(entries)
+
+    @staticmethod
+    def _format_detail_iterable(details: Iterable[Any]) -> str | None:
+        """Format details provided as an iterable collection."""
+        entries: list[str] = []
+        for item in details:
+            if isinstance(item, Mapping):
+                inner = ", ".join(f"{k}={v}" for k, v in item.items())
+                entries.append(f"  - {inner if inner else '{}'}")
+            else:
+                entries.append(f"  - {item}")
+
+        if not entries:
+            return None
+
+        return "Details:\n" + "\n".join(entries)
+
     def _format_validation_errors(self, errors: list[Any]) -> str | None:
         """Render validation errors into a human-readable string."""
         entries: list[str] = []
@@ -365,6 +403,22 @@ class BaseClient:
 
         return "Validation errors:\n" + "\n".join(entries)
 
+    @staticmethod
+    def _is_no_content_response(response: httpx.Response) -> bool:
+        """Return True when the response contains no content."""
+        return response.status_code == 204
+
+    @staticmethod
+    def _is_success_status(response: httpx.Response) -> bool:
+        """Return True for successful HTTP status codes."""
+        return 200 <= response.status_code < 300
+
+    def _handle_error_response(self, response: httpx.Response) -> None:
+        """Raise an API error for non-success responses."""
+        error_message = self._get_error_message(response)
+        parsed_content = self._parse_response_content(response)
+        self._raise_api_error(response.status_code, error_message, payload=parsed_content)
+
     def _handle_response(
         self,
         response: httpx.Response,
@@ -373,24 +427,17 @@ class BaseClient:
     ) -> Any:
         """Handle HTTP response with proper error handling."""
         # Handle no-content success before general error handling
-        if response.status_code == 204:
+        if self._is_no_content_response(response):
             return None
 
-        # Handle error status codes
-        if not (200 <= response.status_code < 300):
-            error_message = self._get_error_message(response)
-            # Try to parse response content for payload
-            parsed_content = self._parse_response_content(response)
-            self._raise_api_error(
-                response.status_code, error_message, payload=parsed_content
-            )
-            return None  # Won't be reached but helps with type checking
-
-        parsed = self._parse_response_content(response)
-        if parsed is None:
-            return None
+        if self._is_success_status(response):
+            parsed = self._parse_response_content(response)
+            if parsed is None:
+                return None
+            return self._handle_success_response(parsed, unwrap=unwrap)
 
-        return self._handle_success_response(parsed, unwrap=unwrap)
+        self._handle_error_response(response)
+        return None
 
     def _raise_api_error(
         self,
@@ -435,12 +482,7 @@ class BaseClient:
 
     def close(self) -> None:
         """Close the HTTP client."""
-        if (
-            hasattr(self, "http_client")
-            and self.http_client
-            and not self._session_scoped
-            and not self._parent_client
-        ):
+        if hasattr(self, "http_client") and self.http_client and not self._session_scoped and not self._parent_client:
             self.http_client.close()
 
     def __enter__(self) -> "BaseClient":

glaip_sdk/client/mcps.py

@@ -179,9 +179,7 @@ class MCPClient(BaseClient):
         update_data = {
             "name": name if name is not None else current_mcp.name,
             "type": DEFAULT_MCP_TYPE,  # Required by backend, MCPs are always server type
-            "transport": kwargs.get(
-                "transport", getattr(current_mcp, "transport", DEFAULT_MCP_TRANSPORT)
-            ),
+            "transport": kwargs.get("transport", getattr(current_mcp, "transport", DEFAULT_MCP_TRANSPORT)),
         }
 
         # Handle description with proper None handling