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

glaip_sdk/client/agents.py

@@ -1,4 +1,4 @@
-#!/usr/bin/env python3
+# pylint: disable=duplicate-code
 """Agent client for AIP SDK.
 
 Authors:
@@ -9,23 +9,28 @@ Authors:
 import asyncio
 import json
 import logging
+import warnings
 from collections.abc import AsyncGenerator, Callable, Iterator, Mapping
 from contextlib import asynccontextmanager
 from os import PathLike
 from pathlib import Path
-from typing import Any, BinaryIO
+from typing import TYPE_CHECKING, Any, BinaryIO
+
+if TYPE_CHECKING:
+    from glaip_sdk.client.schedules import ScheduleClient
+    from glaip_sdk.hitl.remote import RemoteHITLHandler
 
 import httpx
 from glaip_sdk.agents import Agent
-from glaip_sdk.client._agent_payloads import (
+from glaip_sdk.client.agent_runs import AgentRunsClient
+from glaip_sdk.client.base import BaseClient
+from glaip_sdk.client.mcps import MCPClient
+from glaip_sdk.client.payloads.agent import (
     AgentCreateRequest,
     AgentListParams,
     AgentListResult,
     AgentUpdateRequest,
 )
-from glaip_sdk.client.agent_runs import AgentRunsClient
-from glaip_sdk.client.base import BaseClient
-from glaip_sdk.client.mcps import MCPClient
 from glaip_sdk.client.run_rendering import (
     AgentRunRenderingManager,
     compute_timeout_seconds,
@@ -38,10 +43,10 @@ from glaip_sdk.config.constants import (
     DEFAULT_AGENT_RUN_TIMEOUT,
     DEFAULT_AGENT_TYPE,
     DEFAULT_AGENT_VERSION,
-    DEFAULT_MODEL,
 )
 from glaip_sdk.exceptions import NotFoundError, ValidationError
 from glaip_sdk.models import AgentResponse
+from glaip_sdk.models.constants import DEFAULT_MODEL
 from glaip_sdk.payload_schemas.agent import list_server_only_fields
 from glaip_sdk.utils.agent_config import normalize_agent_config_for_import
 from glaip_sdk.utils.client_utils import (
@@ -251,19 +256,134 @@ class AgentClient(BaseClient):
         self,
         *,
         parent_client: BaseClient | None = None,
+        lm_cache_ttl: float = 3600.0,
         **kwargs: Any,
     ) -> None:
         """Initialize the agent client.
 
         Args:
-            parent_client: Parent client to adopt session/config from
-            **kwargs: Additional arguments for standalone initialization
+            parent_client: Parent client to adopt session/config from.
+            lm_cache_ttl: TTL for the language model list cache in seconds.
+                Defaults to 3600 (1 hour).
+            **kwargs: Additional arguments for standalone initialization.
         """
         super().__init__(parent_client=parent_client, **kwargs)
         self._renderer_manager = AgentRunRenderingManager(logger)
         self._tool_client: ToolClient | None = None
         self._mcp_client: MCPClient | None = None
         self._runs_client: AgentRunsClient | None = None
+        self._schedule_client: ScheduleClient | None = None
+
+        self._lm_cache: list[dict[str, Any]] | None = None
+        self._lm_cache_time: float = 0.0
+        self._lm_cache_ttl: float = lm_cache_ttl
+
+    def clear_language_model_cache(self) -> None:
+        """Invalidate the language model list cache.
+
+        Forces the next call to list_language_models() to fetch a fresh list
+        from the server.
+        """
+        self._lm_cache = None
+        self._lm_cache_time = 0.0
+        logger.debug("Language model cache invalidated.")
+
+    def _resolve_language_model_id(self, model_str: str | None) -> str | None:
+        """Resolve a friendly model name to a server language model ID.
+
+        Handles provider name mapping (e.g., 'deepinfra/model' → 'openai-compatible/model')
+        by checking both the original provider name and its driver equivalent.
+
+        Args:
+            model_str: The model string to resolve (e.g., 'openai/gpt-4o', 'deepinfra/Qwen3-30B').
+
+        Returns:
+            The resolved server model ID (UUID), or None if not found.
+
+        Examples:
+            >>> _resolve_language_model_id("openai/gpt-4o")
+            "uuid-1234-..."
+            >>> _resolve_language_model_id("deepinfra/Qwen3-30B")  # Maps to openai-compatible
+            "uuid-5678-..."
+        """
+        if not model_str:
+            return None
+
+        # If resolution is explicitly disabled (e.g. in unit tests to avoid extra API calls), skip it
+        if getattr(self, "_skip_model_resolution", False):
+            return None
+
+        try:
+            models = self.list_language_models()
+
+            # Try exact match first
+            model_id = self._find_exact_model_match(model_str, models)
+            if model_id:
+                return model_id
+
+            # Try with provider-to-driver mapping
+            return self._try_resolve_with_driver_mapping(model_str, models)
+        except Exception:
+            pass
+
+        return None
+
+    def _find_exact_model_match(self, model_str: str, models: list[dict[str, Any]]) -> str | None:
+        """Find exact model match in models list.
+
+        Args:
+            model_str: Model string to match.
+            models: List of language model dictionaries from server.
+
+        Returns:
+            Model ID (UUID) if found, None otherwise.
+        """
+        for model_info in models:
+            provider = model_info.get("provider")
+            name = model_info.get("name")
+            if provider and name:
+                full_name = f"{provider}/{name}"
+                if full_name == model_str:
+                    return model_info.get("id")
+            if name == model_str:
+                return model_info.get("id")
+        return None
+
+    def _try_resolve_with_driver_mapping(self, model_str: str, models: list[dict[str, Any]]) -> str | None:
+        """Try to resolve model using provider-to-driver mapping.
+
+        Maps provider names to their driver implementations (e.g., deepinfra → openai-compatible)
+        and searches the models list with the driver name.
+
+        Args:
+            model_str: Model string in provider/model format (e.g., "deepinfra/Qwen3-30B").
+            models: List of language model dictionaries from server.
+
+        Returns:
+            Model ID (UUID) if found, None otherwise.
+        """
+        if "/" not in model_str:
+            return None
+
+        from glaip_sdk.models._provider_mappings import get_driver  # noqa: PLC0415
+
+        provider, model_name = model_str.split("/", 1)
+        driver = get_driver(provider)
+
+        # Only try with driver if it's different from provider
+        if driver == provider:
+            return None
+
+        driver_model_str = f"{driver}/{model_name}"
+        for model_info in models:
+            provider_field = model_info.get("provider")
+            name_field = model_info.get("name")
+            if provider_field and name_field:
+                full_name = f"{provider_field}/{name_field}"
+                if full_name == driver_model_str:
+                    return model_info.get("id")
+
+        return None
 
     def list_agents(
         self,
@@ -411,6 +531,7 @@ class AgentClient(BaseClient):
         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 stream events from an HTTP response.
 
@@ -420,6 +541,7 @@ class AgentClient(BaseClient):
             timeout_seconds: Timeout in seconds.
             agent_name: Optional agent name.
             meta: Metadata dictionary.
+            hitl_handler: Optional HITL handler for approval callbacks.
 
         Returns:
             Tuple of (final_text, stats_usage, started_monotonic, finished_monotonic).
@@ -431,6 +553,7 @@ class AgentClient(BaseClient):
             timeout_seconds,
             agent_name,
             meta,
+            hitl_handler=hitl_handler,
         )
 
     def _finalize_renderer(
@@ -453,8 +576,13 @@ class AgentClient(BaseClient):
         Returns:
             Final text string.
         """
+        from glaip_sdk.client.run_rendering import (  # noqa: PLC0415
+            finalize_render_manager,
+        )
+
         manager = self._get_renderer_manager()
-        return manager.finalize_renderer(
+        return finalize_render_manager(
+            manager,
             renderer,
             final_text,
             stats_usage,
@@ -482,6 +610,20 @@ class AgentClient(BaseClient):
             self._mcp_client = MCPClient(parent_client=self)
         return self._mcp_client
 
+    @property
+    def schedules(self) -> "ScheduleClient":
+        """Get or create the schedule client instance.
+
+        Returns:
+            ScheduleClient instance.
+        """
+        if self._schedule_client is None:
+            # Import here to avoid circular import
+            from glaip_sdk.client.schedules import ScheduleClient  # noqa: PLC0415
+
+            self._schedule_client = ScheduleClient(parent_client=self)
+        return self._schedule_client
+
     def _normalise_reference_entry(
         self,
         entry: Any,
@@ -749,10 +891,18 @@ class AgentClient(BaseClient):
             plural_label="MCPs",
         )
 
-    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__)
+    def _validate_agent_basics(self, known: dict[str, Any]) -> tuple[str, str]:
+        """Validate and extract basic agent fields.
+
+        Args:
+            known: Known fields dictionary.
+
+        Returns:
+            Tuple of (name, validated_instruction).
 
+        Raises:
+            ValueError: If name or instruction is empty/whitespace.
+        """
         name = known.pop("name", None)
         instruction = known.pop("instruction", None)
         if not name or not str(name).strip():
@@ -761,9 +911,20 @@ class AgentClient(BaseClient):
             raise ValueError("Agent instruction cannot be empty or whitespace")
 
         validated_instruction = validate_agent_instruction(str(instruction))
-        _normalise_sequence_fields(known)
+        return str(name).strip(), validated_instruction
 
-        resolved_model = known.pop("model", None) or DEFAULT_MODEL
+    def _resolve_all_resources(
+        self, known: dict[str, Any], extras: dict[str, Any]
+    ) -> tuple[list[str] | None, list[str] | None, list[str] | None]:
+        """Resolve all resource IDs (tools, agents, mcps).
+
+        Args:
+            known: Known fields dictionary.
+            extras: Extra fields dictionary.
+
+        Returns:
+            Tuple of (resolved_tools, resolved_agents, resolved_mcps).
+        """
         tool_refs = extras.pop("_tool_refs", None)
         agent_refs = extras.pop("_agent_refs", None)
         mcp_refs = extras.pop("_mcp_refs", None)
@@ -776,10 +937,56 @@ class AgentClient(BaseClient):
         resolved_agents = self._resolve_agent_ids(agents_raw, agent_refs)
         resolved_mcps = self._resolve_mcp_ids(mcps_raw, mcp_refs)
 
+        return resolved_tools, resolved_agents, resolved_mcps
+
+    def _process_model_fields(
+        self, resolved_model: Any, known: dict[str, Any]
+    ) -> tuple[str, str | None, str | None, str | None]:
+        """Process model fields and extract language model ID.
+
+        Args:
+            resolved_model: Resolved model (string or Model object).
+            known: Known fields dictionary.
+
+        Returns:
+            Tuple of (resolved_model_str, language_model_id, provider, model_name).
+        """
+        from glaip_sdk.models import Model  # noqa: PLC0415
+
+        if isinstance(resolved_model, Model):
+            if resolved_model.credentials or resolved_model.hyperparameters or resolved_model.base_url:
+                warnings.warn(
+                    "Model object contains local configuration (credentials, hyperparameters, or base_url) "
+                    "which is ignored for remote deployment. These fields are only used for local execution.",
+                    UserWarning,
+                    stacklevel=2,
+                )
+            resolved_model = resolved_model.id
+
+        # Validate and normalize string models (handles bare name deprecation)
+        if isinstance(resolved_model, str):
+            from glaip_sdk.models._validation import _validate_model  # noqa: PLC0415
+
+            resolved_model = _validate_model(resolved_model)
+
         language_model_id = known.pop("language_model_id", None)
+        if not language_model_id and isinstance(resolved_model, str):
+            language_model_id = self._resolve_language_model_id(resolved_model)
+
         provider = known.pop("provider", None)
         model_name = known.pop("model_name", None)
 
+        return resolved_model, language_model_id, provider, model_name
+
+    def _extract_agent_metadata(self, known: dict[str, Any]) -> tuple[str, str, str]:
+        """Extract agent type, framework, and version.
+
+        Args:
+            known: Known fields dictionary.
+
+        Returns:
+            Tuple of (agent_type, framework, version).
+        """
         agent_type_value = known.pop("agent_type", None)
         fallback_type_value = known.pop("type", None)
         if agent_type_value is None:
@@ -787,6 +994,26 @@ class AgentClient(BaseClient):
 
         framework_value = known.pop("framework", None) or DEFAULT_AGENT_FRAMEWORK
         version_value = known.pop("version", None) or DEFAULT_AGENT_VERSION
+
+        return agent_type_value, framework_value, version_value
+
+    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__)
+
+        # Validate and extract basic fields
+        name, validated_instruction = self._validate_agent_basics(known)
+        _normalise_sequence_fields(known)
+
+        # Resolve model and resources
+        resolved_model = known.pop("model", None) or DEFAULT_MODEL
+        resolved_tools, resolved_agents, resolved_mcps = self._resolve_all_resources(known, extras)
+
+        # Process model and language model ID
+        resolved_model, language_model_id, provider, model_name = self._process_model_fields(resolved_model, known)
+
+        # Extract agent type, framework, version
+        agent_type_value, framework_value, version_value = self._extract_agent_metadata(known)
         account_id = known.pop("account_id", None)
         description = known.pop("description", None)
         metadata = _prepare_agent_metadata(known.pop("metadata", None))
@@ -799,7 +1026,7 @@ class AgentClient(BaseClient):
         final_extras.setdefault("model", resolved_model)
 
         request = AgentCreateRequest(
-            name=str(name).strip(),
+            name=name,
             instruction=validated_instruction,
             model=resolved_model,
             language_model_id=language_model_id,
@@ -877,6 +1104,29 @@ class AgentClient(BaseClient):
         """Backward-compatible helper to create an agent from a configuration file."""
         return self.create_agent(file=file_path, **overrides)
 
+    def _resolve_update_model_fields(self, known: dict[str, Any]) -> None:
+        """Resolve model fields in-place for update payload if present.
+
+        If 'model' or 'language_model_id' keys exist in the known fields dict,
+        this method resolves them into 'language_model_id', 'provider', and 'model_name'
+        using the standard resolution logic, ensuring consistency with create_agent.
+
+        Args:
+            known: The dictionary of known fields to check and update in-place.
+        """
+        if "model" in known or "language_model_id" in known:
+            model_val = known.pop("model", None)
+            r_model, r_id, r_prov, r_name = self._process_model_fields(model_val, known)
+
+            if r_model is not None:
+                known["model"] = r_model
+            if r_id is not None:
+                known["language_model_id"] = r_id
+            if r_prov is not None:
+                known["provider"] = r_prov
+            if r_name is not None:
+                known["model_name"] = r_name
+
     def _update_agent_from_payload(
         self,
         agent_id: str,
@@ -902,6 +1152,8 @@ class AgentClient(BaseClient):
         if mcps_value is not None:
             mcps_value = self._resolve_mcp_ids(mcps_value, mcp_refs)  # pragma: no cover
 
+        self._resolve_update_model_fields(known)
+
         request = AgentUpdateRequest(
             name=known.pop("name", None),
             instruction=known.pop("instruction", None),
@@ -1096,6 +1348,7 @@ class AgentClient(BaseClient):
         *,
         renderer: RichStreamRenderer | str | None = "auto",
         runtime_config: dict[str, Any] | None = None,
+        hitl_handler: "RemoteHITLHandler | None" = None,
         **kwargs,
     ) -> str:
         """Run an agent with a message, streaming via a renderer.
@@ -1113,6 +1366,8 @@ class AgentClient(BaseClient):
                     "mcp_configs": {"mcp-id": {"setting": "on"}},
                     "agent_config": {"planning": True},
                 }
+            hitl_handler: Optional RemoteHITLHandler for approval callbacks.
+                Set GLAIP_HITL_AUTO_APPROVE=true for auto-approval without handler.
             **kwargs: Additional arguments to pass to the run API.
 
         Returns:
@@ -1169,6 +1424,7 @@ class AgentClient(BaseClient):
                     timeout_seconds,
                     agent_name,
                     meta,
+                    hitl_handler=hitl_handler,
                 )
 
         except KeyboardInterrupt:
@@ -1185,6 +1441,13 @@ class AgentClient(BaseClient):
             if multipart_data:
                 multipart_data.close()
 
+        # Wait for pending HITL decisions before returning
+        if hitl_handler and hasattr(hitl_handler, "wait_for_pending_decisions"):
+            try:
+                hitl_handler.wait_for_pending_decisions(timeout=30)
+            except Exception as e:
+                logger.warning(f"Error waiting for HITL decisions: {e}")
+
         return self._finalize_renderer(
             r,
             final_text,
@@ -1266,6 +1529,7 @@ class AgentClient(BaseClient):
         *,
         request_timeout: float | None = None,
         runtime_config: dict[str, Any] | None = None,
+        hitl_handler: "RemoteHITLHandler | None" = None,
         **kwargs,
     ) -> AsyncGenerator[dict, None]:
         """Async run an agent with a message, yielding streaming JSON chunks.
@@ -1282,16 +1546,26 @@ class AgentClient(BaseClient):
                     "mcp_configs": {"mcp-id": {"setting": "on"}},
                     "agent_config": {"planning": True},
                 }
+            hitl_handler: Optional HITL handler for remote approval requests.
+                Note: Async HITL support is currently deferred. This parameter
+                is accepted for API consistency but will raise NotImplementedError
+                if provided.
             **kwargs: Additional arguments (chat_history, pii_mapping, etc.)
 
         Yields:
             Dictionary containing parsed JSON chunks from the streaming response
 
         Raises:
+            NotImplementedError: If hitl_handler is provided (async HITL not yet supported)
             AgentTimeoutError: When agent execution times out
             httpx.TimeoutException: When general timeout occurs
             Exception: For other unexpected errors
         """
+        if hitl_handler is not None:
+            raise NotImplementedError(
+                "Async HITL support is currently deferred. "
+                "Please use the synchronous run_agent() method with hitl_handler."
+            )
         # Include runtime_config in kwargs only when caller hasn't already provided it
         if runtime_config is not None and "runtime_config" not in kwargs:
             kwargs["runtime_config"] = runtime_config

glaip_sdk/client/base.py

@@ -8,6 +8,7 @@ Authors:
 
 import logging
 import os
+import time
 from collections.abc import Iterable, Mapping
 from typing import Any, NoReturn, Union
 
@@ -89,6 +90,11 @@ class BaseClient:
             client_log.info(f"Initializing client with API URL: {self.api_url}")
             self.http_client = self._build_client(timeout)
 
+        # Language model cache (shared by all clients)
+        self._lm_cache: list[dict[str, Any]] | None = None
+        self._lm_cache_time: float = 0.0
+        self._lm_cache_ttl: float = 300.0  # 5 minutes TTL
+
     def _build_client(self, timeout: float) -> httpx.Client:
         """Build HTTP client with configuration."""
         # For streaming operations, we need more generous read timeouts
@@ -481,6 +487,25 @@ class BaseClient:
             request_id=request_id,
         )
 
+    def list_language_models(self, force_refresh: bool = False) -> list[dict[str, Any]]:
+        """List available language models with TTL caching.
+
+        Args:
+            force_refresh: Whether to ignore cache and fetch fresh list.
+
+        Returns:
+            List of available language models.
+        """
+        now = time.monotonic()
+        if not force_refresh and self._lm_cache is not None:
+            if now - self._lm_cache_time < self._lm_cache_ttl:
+                return self._lm_cache
+
+        models = self._request("GET", "/language-models") or []
+        self._lm_cache = models
+        self._lm_cache_time = now
+        return models
+
     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:

glaip_sdk/client/hitl.py

@@ -0,0 +1,136 @@
+#!/usr/bin/env python3
+"""HITL REST client for manual approval operations.
+
+Authors:
+    GLAIP SDK Team
+"""
+
+from typing import Any
+
+from glaip_sdk.client.base import BaseClient
+from glaip_sdk.hitl.base import HITLDecision
+
+
+class HITLClient(BaseClient):
+    """Client for HITL REST endpoints.
+
+    Use for manual approval workflows separate from agent runs.
+
+    Example:
+        >>> # List pending approvals
+        >>> pending = client.hitl.list_pending()
+        >>>
+        >>> # Approve a request
+        >>> client.hitl.approve(
+        ...     request_id="bc4d0a77-7800-470e-a91c-7fd663a66b4d",
+        ...     operator_input="Verified and approved",
+        ... )
+    """
+
+    def approve(
+        self,
+        request_id: str,
+        operator_input: str | None = None,
+        run_id: str | None = None,
+    ) -> dict[str, Any]:
+        """Approve a HITL request.
+
+        Args:
+            request_id: HITL request ID from SSE stream
+            operator_input: Optional notes/reason for approval
+            run_id: Optional client-side run correlation ID
+
+        Returns:
+            Response dict: {"status": "ok", "message": "..."}
+        """
+        return self._post_decision(
+            request_id,
+            HITLDecision.APPROVED,
+            operator_input,
+            run_id,
+        )
+
+    def reject(
+        self,
+        request_id: str,
+        operator_input: str | None = None,
+        run_id: str | None = None,
+    ) -> dict[str, Any]:
+        """Reject a HITL request.
+
+        Args:
+            request_id: HITL request ID
+            operator_input: Optional reason for rejection
+            run_id: Optional run correlation ID
+
+        Returns:
+            Response dict
+        """
+        return self._post_decision(
+            request_id,
+            HITLDecision.REJECTED,
+            operator_input,
+            run_id,
+        )
+
+    def skip(
+        self,
+        request_id: str,
+        operator_input: str | None = None,
+        run_id: str | None = None,
+    ) -> dict[str, Any]:
+        """Skip a HITL request.
+
+        Args:
+            request_id: HITL request ID
+            operator_input: Optional notes
+            run_id: Optional run correlation ID
+
+        Returns:
+            Response dict
+        """
+        return self._post_decision(
+            request_id,
+            HITLDecision.SKIPPED,
+            operator_input,
+            run_id,
+        )
+
+    def _post_decision(
+        self,
+        request_id: str,
+        decision: HITLDecision,
+        operator_input: str | None,
+        run_id: str | None,
+    ) -> dict[str, Any]:
+        """Post HITL decision to backend."""
+        payload = {
+            "request_id": request_id,
+            "decision": decision.value,
+        }
+
+        if operator_input:
+            payload["operator_input"] = operator_input
+        if run_id:
+            payload["run_id"] = run_id
+
+        return self._request("POST", "/agents/hitl/decision", json=payload)
+
+    def list_pending(self) -> list[dict[str, Any]]:
+        """List all pending HITL requests.
+
+        Returns:
+            List of pending request dicts with metadata:
+            [
+                {
+                    "request_id": "...",
+                    "tool": "...",
+                    "arguments": {...},
+                    "created_at": "...",
+                    "agent_id": "...",
+                    "hitl_metadata": {...},
+                },
+                ...
+            ]
+        """
+        return self._request("GET", "/agents/hitl/pending")