glaip-sdk 0.1.2__py3-none-any.whl → 0.7.17__py3-none-any.whl

glaip_sdk/client/{_agent_payloads.py → payloads/agent/requests.py}

@@ -1,11 +1,15 @@
-#!/usr/bin/env python3
-"""Shared helpers for Agent client payload construction and query handling."""
+"""Agent request payload types and helpers.
 
+Authors:
+    Raymond Christopher (raymond.christopher@gdplabs.id)
+"""
+
+# pylint: disable=duplicate-code
 from __future__ import annotations
 
 from collections.abc import Callable, Mapping, MutableMapping, Sequence
 from copy import deepcopy
-from dataclasses import dataclass, field
+from dataclasses import dataclass
 from typing import Any
 
 from glaip_sdk.config.constants import (
@@ -13,12 +17,9 @@ from glaip_sdk.config.constants import (
     DEFAULT_AGENT_PROVIDER,
     DEFAULT_AGENT_TYPE,
     DEFAULT_AGENT_VERSION,
-    DEFAULT_MODEL,
-)
-from glaip_sdk.payload_schemas.agent import (
-    AgentImportOperation,
-    get_import_field_plan,
 )
+from glaip_sdk.models.constants import DEFAULT_MODEL
+from glaip_sdk.payload_schemas.agent import AgentImportOperation, get_import_field_plan
 from glaip_sdk.utils.client_utils import extract_ids
 
 _LM_CONFLICT_KEYS = {
@@ -99,6 +100,11 @@ def resolve_language_model_fields(
     resolved_model = model_name or model or default_model
     resolved_provider = provider if provider is not None else default_provider
 
+    if resolved_model and isinstance(resolved_model, str) and "/" in resolved_model:
+        parts = resolved_model.split("/", 1)
+        resolved_provider = parts[0]
+        resolved_model = parts[1]
+
     result: dict[str, Any] = {}
     if resolved_model is not None:
         result["model_name"] = resolved_model
@@ -209,6 +215,11 @@ class AgentListParams:
         return params
 
     def _base_filter_params(self) -> dict[str, Any]:
+        """Build base filter parameters from non-None fields.
+
+        Returns:
+            Dictionary of filter parameters with non-None values.
+        """
         return {
             key: value
             for key, value in (
@@ -221,6 +232,11 @@ class AgentListParams:
         }
 
     def _apply_pagination_params(self, params: dict[str, Any]) -> None:
+        """Apply pagination parameters to the params dictionary.
+
+        Args:
+            params: Dictionary to update with pagination parameters.
+        """
         if self.limit is not None:
             if not 1 <= self.limit <= 100:
                 raise ValueError("limit must be between 1 and 100 inclusive")
@@ -238,6 +254,11 @@ class AgentListParams:
             params["sync_langflow_agents"] = str(self.sync_langflow_agents).lower()
 
     def _apply_timestamp_filters(self, params: dict[str, Any]) -> None:
+        """Apply timestamp filter parameters to the params dictionary.
+
+        Args:
+            params: Dictionary to update with timestamp filter parameters.
+        """
         timestamp_filters = {
             "created_at_start": self.created_at_start,
             "created_at_end": self.created_at_end,
@@ -249,6 +270,11 @@ class AgentListParams:
                 params[key] = value
 
     def _apply_metadata_filters(self, params: dict[str, Any]) -> None:
+        """Apply metadata filter parameters to the params dictionary.
+
+        Args:
+            params: Dictionary to update with metadata filter parameters.
+        """
         if not self.metadata:
             return
         for key, value in self.metadata.items():
@@ -256,28 +282,6 @@ class AgentListParams:
                 params[f"metadata.{key}"] = value
 
 
-@dataclass(slots=True)
-class AgentListResult:
-    """Structured response for list_agents that retains pagination metadata."""
-
-    items: list[Any] = field(default_factory=list)
-    total: int | None = None
-    page: int | None = None
-    limit: int | None = None
-    has_next: bool | None = None
-    has_prev: bool | None = None
-    message: str | None = None
-
-    def __len__(self) -> int:  # pragma: no cover - simple delegation
-        return len(self.items)
-
-    def __iter__(self):  # pragma: no cover - simple delegation
-        return iter(self.items)
-
-    def __getitem__(self, index: int) -> Any:  # pragma: no cover - simple delegation
-        return self.items[index]
-
-
 @dataclass(slots=True)
 class AgentCreateRequest:
     """Declarative representation of an agent creation payload."""
@@ -395,41 +399,51 @@ class AgentUpdateRequest:
         return payload
 
 
-__all__ = [
-    "AgentCreateRequest",
-    "AgentListParams",
-    "AgentListResult",
-    "AgentUpdateRequest",
-    "merge_payload_fields",
-    "resolve_language_model_fields",
-]
-
-
 def _build_base_update_payload(request: AgentUpdateRequest, current_agent: Any) -> dict[str, Any]:
+    """Populate immutable agent update fields using request data or existing agent defaults."""
+    # Support both "agent_type" (runtime class) and "type" (API response) attributes
+    current_type = getattr(current_agent, "agent_type", None) or getattr(current_agent, "type", None)
     return {
-        "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,
+        "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 current_type 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]:
+    """Resolve the language-model portion of an update request with sensible fallbacks."""
+    # Check if any LM inputs were provided
+    has_lm_inputs = any(
+        [
+            request.model is not None,
+            request.language_model_id is not None,
+            request.provider is not None,
+            request.model_name is not None,
+        ]
+    )
+
+    if not has_lm_inputs:
+        # No LM inputs provided - preserve existing fields
+        return _existing_language_model_fields(current_agent)
+
+    # LM inputs provided - resolve them (may return defaults if only partial info)
     fields = resolve_language_model_fields(
         model=request.model,
         language_model_id=request.language_model_id,
         provider=request.provider,
         model_name=request.model_name,
     )
-    if not fields:
-        fields = _existing_language_model_fields(current_agent)
     return fields
 
 
 def _collect_optional_update_fields(request: AgentUpdateRequest, current_agent: Any) -> dict[str, Any]:
+    """Collect optional agent fields, preserving current values when updates are absent."""
     result: dict[str, Any] = {}
 
     for field_name, value in (
@@ -468,6 +482,7 @@ def _collect_optional_update_fields(request: AgentUpdateRequest, current_agent:
 
 
 def _collect_relationship_fields(request: AgentUpdateRequest, current_agent: Any) -> dict[str, Any]:
+    """Return relationship identifiers (tools/agents/mcps) for an update request."""
     return {
         "tools": _resolve_relation_ids(request.tools, current_agent, "tools"),
         "agents": _resolve_relation_ids(request.agents, current_agent, "agents"),
@@ -476,6 +491,7 @@ def _collect_relationship_fields(request: AgentUpdateRequest, current_agent: Any
 
 
 def _resolve_agent_config_update(request: AgentUpdateRequest, current_agent: Any) -> dict[str, Any] | None:
+    """Determine the agent_config payload to send, if any."""
     effective_agent_config = _sanitize_agent_config(request.agent_config)
     if effective_agent_config is not None:
         return effective_agent_config

glaip_sdk/client/payloads/agent/responses.py

@@ -0,0 +1,43 @@
+"""Agent response payload types.
+
+Authors:
+    Raymond Christopher (raymond.christopher@gdplabs.id)
+"""
+
+# pylint: disable=duplicate-code
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass(slots=True)
+class AgentListResult:
+    """Structured response for list_agents that retains pagination metadata."""
+
+    items: list[Any] = field(default_factory=list)
+    total: int | None = None
+    page: int | None = None
+    limit: int | None = None
+    has_next: bool | None = None
+    has_prev: bool | None = None
+    message: str | None = None
+
+    def __len__(self) -> int:  # pragma: no cover - simple delegation
+        """Return the number of items in the result list."""
+        return len(self.items)
+
+    def __iter__(self):  # pragma: no cover - simple delegation
+        """Return an iterator over the items in the result list."""
+        return iter(self.items)
+
+    def __getitem__(self, index: int) -> Any:  # pragma: no cover - simple delegation
+        """Get an item from the result list by index.
+
+        Args:
+            index: Index of the item to retrieve.
+
+        Returns:
+            The item at the specified index.
+        """
+        return self.items[index]