glaip-sdk 0.6.19__py3-none-any.whl → 0.7.27__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]

glaip_sdk/client/run_rendering.py

@@ -11,7 +11,10 @@ import json
 import logging
 from collections.abc import AsyncIterable, Callable
 from time import monotonic
-from typing import Any
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from glaip_sdk.hitl.remote import RemoteHITLHandler
 
 import httpx
 from rich.console import Console as _Console
@@ -130,6 +133,7 @@ class AgentRunRenderingManager:
         timeout_seconds: float,
         agent_name: str | None,
         meta: dict[str, Any],
+        hitl_handler: RemoteHITLHandler | None = None,
     ) -> tuple[str, dict[str, Any], float | None, float | None]:
         """Process streaming events and accumulate response."""
         final_text = ""
@@ -153,6 +157,7 @@ class AgentRunRenderingManager:
                     final_text,
                     stats_usage,
                     meta,
+                    hitl_handler=hitl_handler,
                 )
 
                 if controller and getattr(controller, "enabled", False):
@@ -167,6 +172,63 @@ class AgentRunRenderingManager:
         finished_monotonic = monotonic()
         return final_text, stats_usage, started_monotonic, finished_monotonic
 
+    async def _consume_event_stream(
+        self,
+        event_stream: AsyncIterable[dict[str, Any]],
+        renderer: RichStreamRenderer,
+        final_text: str,
+        stats_usage: dict[str, Any],
+        meta: dict[str, Any],
+        skip_final_render: bool,
+        last_rendered_content: str | None,
+        controller: Any | None,
+    ) -> tuple[str, dict[str, Any], float | None]:
+        """Consume event stream and update state.
+
+        Args:
+            event_stream: Async iterable yielding SSE-like event dicts.
+            renderer: Renderer to use for displaying events.
+            final_text: Current accumulated final text.
+            stats_usage: Usage statistics dictionary.
+            meta: Metadata dictionary.
+            skip_final_render: If True, skip rendering final_response events.
+            last_rendered_content: Last rendered content to avoid duplicates.
+            controller: Controller instance.
+
+        Returns:
+            Tuple of (final_text, stats_usage, started_monotonic).
+        """
+        started_monotonic: float | None = None
+
+        async for event in event_stream:
+            if started_monotonic is None:
+                started_monotonic = monotonic()
+
+            parsed_event = self._parse_event(event)
+            if parsed_event is None:
+                continue
+
+            final_text, stats_usage = self._handle_parsed_event(
+                parsed_event,
+                renderer,
+                final_text,
+                stats_usage,
+                meta,
+                skip_final_render=skip_final_render,
+                last_rendered_content=last_rendered_content,
+            )
+
+            content_str = self._extract_content_string(parsed_event)
+            if content_str:
+                last_rendered_content = content_str
+
+            if controller and getattr(controller, "enabled", False):
+                controller.poll(renderer)
+            if parsed_event and self._is_final_event(parsed_event):
+                break
+
+        return final_text, stats_usage, started_monotonic
+
     async def async_process_stream_events(
         self,
         event_stream: AsyncIterable[dict[str, Any]],
@@ -202,35 +264,25 @@ class AgentRunRenderingManager:
             controller.on_stream_start(renderer)
 
         try:
-            async for event in event_stream:
-                if started_monotonic is None:
-                    started_monotonic = monotonic()
-
-                # Parse event if needed (handles both raw SSE and pre-parsed dicts)
-                parsed_event = self._parse_event(event)
-                if parsed_event is None:
-                    continue
-
-                # Process the event and update accumulators
-                final_text, stats_usage = self._handle_parsed_event(
-                    parsed_event,
-                    renderer,
-                    final_text,
-                    stats_usage,
-                    meta,
-                    skip_final_render=skip_final_render,
-                    last_rendered_content=last_rendered_content,
-                )
-
-                # Track last rendered content to avoid duplicates
-                content_str = self._extract_content_string(parsed_event)
-                if content_str:
-                    last_rendered_content = content_str
-
-                if controller and getattr(controller, "enabled", False):
-                    controller.poll(renderer)
-                if parsed_event and self._is_final_event(parsed_event):
-                    break
+            final_text, stats_usage, started_monotonic = await self._consume_event_stream(
+                event_stream,
+                renderer,
+                final_text,
+                stats_usage,
+                meta,
+                skip_final_render,
+                last_rendered_content,
+                controller,
+            )
+        except Exception as e:
+            err_msg = str(e)
+            reason = getattr(getattr(e, "result", None), "reason", None)
+            if reason:
+                final_text = f"⚠️ Guardrail violation: {reason}"
+            elif "⚠️ Guardrail violation" in err_msg or "Content blocked by guardrails" in err_msg:
+                final_text = err_msg
+            else:
+                raise e
         finally:
             if controller and getattr(controller, "enabled", False):
                 controller.on_stream_complete()
@@ -504,6 +556,7 @@ class AgentRunRenderingManager:
         final_text: str,
         stats_usage: dict[str, Any],
         meta: dict[str, Any],
+        hitl_handler: RemoteHITLHandler | None = None,
     ) -> tuple[str, dict[str, Any]]:
         """Process a single streaming event.
 
@@ -513,6 +566,7 @@ class AgentRunRenderingManager:
             final_text: Accumulated text so far.
             stats_usage: Usage statistics dictionary.
             meta: Metadata dictionary.
+            hitl_handler: Optional HITL handler for approval callbacks.
 
         Returns:
             Tuple of (updated_final_text, updated_stats_usage).
@@ -523,6 +577,17 @@ class AgentRunRenderingManager:
             self._logger.debug("Non-JSON SSE fragment skipped")
             return final_text, stats_usage
 
+        # Handle HITL event (non-blocking via thread)
+        if hitl_handler and self._is_hitl_pending_event(ev):
+            try:
+                hitl_handler.handle_hitl_event(ev)
+            except Exception as e:
+                # Log but don't crash stream
+                self._logger.error(
+                    f"HITL handler error: {e}",
+                    exc_info=True,
+                )
+
         kind = (ev.get("metadata") or {}).get("kind")
         renderer.on_event(ev)
 
@@ -590,6 +655,20 @@ class AgentRunRenderingManager:
             return content
         return final_text
 
+    @staticmethod
+    def _is_hitl_pending_event(event: dict[str, Any]) -> bool:
+        """Check if event is a pending HITL approval request.
+
+        Args:
+            event: Parsed event dictionary.
+
+        Returns:
+            True if event is a pending HITL request.
+        """
+        metadata = event.get("metadata", {})
+        hitl_meta = metadata.get("hitl", {})
+        return hitl_meta.get("required") is True and hitl_meta.get("decision") == "pending"
+
     def _handle_run_info_event(
         self,
         ev: dict[str, Any],