glaip-sdk 0.6.5b3__py3-none-any.whl → 0.7.17__py3-none-any.whl

glaip_sdk/client/main.py

@@ -12,13 +12,15 @@ from typing import TYPE_CHECKING, Any
 
 from glaip_sdk.client.agents import AgentClient
 from glaip_sdk.client.base import BaseClient
+from glaip_sdk.client.hitl import HITLClient
 from glaip_sdk.client.mcps import MCPClient
+from glaip_sdk.client.schedules import ScheduleClient
 from glaip_sdk.client.shared import build_shared_config
 from glaip_sdk.client.tools import ToolClient
 
 if TYPE_CHECKING:  # pragma: no cover
     from glaip_sdk.agents import Agent
-    from glaip_sdk.client._agent_payloads import AgentListResult
+    from glaip_sdk.client.payloads.agent import AgentListResult
     from glaip_sdk.mcps import MCP
     from glaip_sdk.tools import Tool
 
@@ -38,6 +40,8 @@ class Client(BaseClient):
         self.agents = AgentClient(**shared_config)
         self.tools = ToolClient(**shared_config)
         self.mcps = MCPClient(**shared_config)
+        self.schedules = ScheduleClient(**shared_config)
+        self.hitl = HITLClient(**shared_config)
 
     # ---- Core API Methods (Public Interface) ----
 
@@ -208,10 +212,6 @@ class Client(BaseClient):
         return self.mcps.get_mcp_tools_from_config(config)
 
     # Language Models
-    def list_language_models(self) -> list[dict]:
-        """List available language models."""
-        data = self._request("GET", "/language-models")
-        return data or []
 
     # ---- Timeout propagation ----
     @property
@@ -236,6 +236,8 @@ class Client(BaseClient):
                 self.tools.http_client = self.http_client
             if hasattr(self, "mcps"):
                 self.mcps.http_client = self.http_client
+            if hasattr(self, "schedules"):
+                self.schedules.http_client = self.http_client
         except Exception:
             pass
 

glaip_sdk/client/mcps.py

@@ -85,26 +85,56 @@ class MCPClient(BaseClient):
         response = MCPResponse(**full_mcp_data)
         return MCP.from_response(response, client=self)
 
-    def update_mcp(self, mcp_id: str, **kwargs) -> MCP:
+    def update_mcp(self, mcp_id: str | MCP, **kwargs) -> MCP:
         """Update an existing MCP.
 
-        Automatically chooses between PUT (full update) and PATCH (partial update)
-        based on the provided fields:
-        - Uses PUT if name, config, and transport are all provided (full update)
-        - Uses PATCH otherwise (partial update)
+        Notes:
+            - Payload construction is centralized via ``_build_update_payload`` so required
+              defaults (e.g., ``type``) and value normalization stay consistent across SDK and CLI.
+            - For backward compatibility, still chooses PATCH vs PUT based on which fields the
+              caller provided, but uses the SDK payload builder for the final payload.
         """
-        # Check if all required fields for full update are provided
+        # Backward-compatible: allow passing an MCP instance to avoid an extra fetch.
+        if isinstance(mcp_id, MCP):
+            current_mcp = mcp_id
+            if not current_mcp.id:
+                raise ValueError("MCP instance has no id; cannot update.")
+            mcp_id_value = str(current_mcp.id)
+        else:
+            current_mcp = None
+            mcp_id_value = mcp_id
+
         required_fields = {"name", "config", "transport"}
         provided_fields = set(kwargs.keys())
+        method = "PUT" if required_fields.issubset(provided_fields) else "PATCH"
+
+        if not kwargs:
+            data = self._request(method, f"{MCPS_ENDPOINT}{mcp_id_value}", json={})
+            response = MCPResponse(**data)
+            return MCP.from_response(response, client=self)
+
+        if current_mcp is None:
+            current_mcp = self.get_mcp_by_id(mcp_id_value)
+
+        payload_kwargs = kwargs.copy()
+        name = payload_kwargs.pop("name", None)
+        description = payload_kwargs.pop("description", None)
+        full_payload = self._build_update_payload(
+            current_mcp=current_mcp,
+            name=name,
+            description=description,
+            **payload_kwargs,
+        )
 
-        if required_fields.issubset(provided_fields):
-            # All required fields provided - use full update (PUT)
-            method = "PUT"
+        if method == "PUT":
+            json_payload = full_payload
         else:
-            # Partial update - use PATCH
-            method = "PATCH"
+            json_payload = {key: full_payload[key] for key in provided_fields if key in full_payload}
+            json_payload["type"] = full_payload["type"]
+            if "config" in provided_fields and "transport" not in provided_fields and "transport" in full_payload:
+                json_payload["transport"] = full_payload["transport"]
 
-        data = self._request(method, f"{MCPS_ENDPOINT}{mcp_id}", json=kwargs)
+        data = self._request(method, f"{MCPS_ENDPOINT}{mcp_id_value}", json=json_payload)
         response = MCPResponse(**data)
         return MCP.from_response(response, client=self)
 
@@ -188,7 +218,8 @@ class MCPClient(BaseClient):
         **kwargs,
     ) -> MCP:
         """Find by name and update, or create if not found."""
-        existing = self.find_mcps(name)
+        all_mcps = self.list_mcps()
+        existing = [mcp for mcp in all_mcps if mcp.name.lower() == name.lower()]
 
         if len(existing) == 1:
             logger.info("Updating existing MCP: %s", name)

glaip_sdk/client/payloads/agent/__init__.py

@@ -0,0 +1,23 @@
+"""Agent payload types for requests and responses.
+
+Authors:
+    Raymond Christopher (raymond.christopher@gdplabs.id)
+"""
+
+from glaip_sdk.client.payloads.agent.requests import (
+    AgentCreateRequest,
+    AgentListParams,
+    AgentUpdateRequest,
+    merge_payload_fields,
+    resolve_language_model_fields,
+)
+from glaip_sdk.client.payloads.agent.responses import AgentListResult
+
+__all__ = [
+    "AgentCreateRequest",
+    "AgentListParams",
+    "AgentListResult",
+    "AgentUpdateRequest",
+    "merge_payload_fields",
+    "resolve_language_model_fields",
+]

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,8 +17,8 @@ from glaip_sdk.config.constants import (
     DEFAULT_AGENT_PROVIDER,
     DEFAULT_AGENT_TYPE,
     DEFAULT_AGENT_VERSION,
-    DEFAULT_MODEL,
 )
+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
 
@@ -96,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
@@ -273,38 +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 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]
-
-
 @dataclass(slots=True)
 class AgentCreateRequest:
     """Declarative representation of an agent creation payload."""
@@ -422,16 +399,6 @@ 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
@@ -451,14 +418,27 @@ def _build_base_update_payload(request: AgentUpdateRequest, current_agent: Any)
 
 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
 
 

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]