glaip-sdk 0.0.6a0__py3-none-any.whl → 0.0.8__py3-none-any.whl

glaip_sdk/cli/utils.py

@@ -8,13 +8,17 @@ from __future__ import annotations
 
 import io
 import json
+import logging
 import os
 import platform
 import shlex
 import shutil
 import subprocess
+import sys
 import tempfile
 from collections.abc import Callable
+from contextlib import AbstractContextManager, nullcontext
+from pathlib import Path
 from typing import TYPE_CHECKING, Any
 
 import click
@@ -29,15 +33,15 @@ try:
     from prompt_toolkit.shortcuts import prompt
 
     _HAS_PTK = True
-except Exception:
+except Exception:  # pragma: no cover - optional dependency
     _HAS_PTK = False
 
 try:
     import questionary
-except Exception:
+except Exception:  # pragma: no cover - optional dependency
     questionary = None
 
-if TYPE_CHECKING:
+if TYPE_CHECKING:  # pragma: no cover - import-only during type checking
     from glaip_sdk import Client
 from glaip_sdk.cli.commands.configure import load_config
 from glaip_sdk.rich_components import AIPPanel, AIPTable
@@ -49,6 +53,7 @@ from glaip_sdk.utils.rendering.renderer import (
 )
 
 console = Console()
+logger = logging.getLogger("glaip_sdk.cli.utils")
 
 
 # ----------------------------- Context helpers ---------------------------- #
@@ -100,7 +105,7 @@ def _prepare_pager_env(
 
 def _render_ansi(
     renderable: Any,
-) -> str:  # pragma: no cover - rendering requires real terminal
+) -> str:
     """Render a Rich renderable to an ANSI string suitable for piping to 'less'."""
     buf = io.StringIO()
     tmp_console = Console(
@@ -116,7 +121,7 @@ def _render_ansi(
     return buf.getvalue()
 
 
-def _pager_header() -> str:  # pragma: no cover - terminal UI helper
+def _pager_header() -> str:
     v = (os.getenv("AIP_PAGER_HEADER", "1") or "1").strip().lower()
     if v in {"0", "false", "off"}:
         return ""
@@ -224,10 +229,80 @@ def _get_view(ctx: Any) -> str:
     return fallback or "rich"
 
 
+def spinner_context(
+    ctx: Any | None,
+    message: str,
+    *,
+    console_override: Console | None = None,
+    spinner: str = "dots",
+    spinner_style: str = "cyan",
+) -> AbstractContextManager[Any]:
+    """Return a context manager that renders a spinner when appropriate."""
+
+    active_console = console_override or console
+    if not _can_use_spinner(ctx, active_console):
+        return nullcontext()
+
+    return active_console.status(
+        message,
+        spinner=spinner,
+        spinner_style=spinner_style,
+    )
+
+
+def _can_use_spinner(ctx: Any | None, active_console: Console) -> bool:
+    """Check if spinner output is allowed in the current environment."""
+
+    if ctx is not None:
+        tty_enabled = bool(get_ctx_value(ctx, "tty", True))
+        view = (_get_view(ctx) or "rich").lower()
+        if not tty_enabled or view not in {"", "rich"}:
+            return False
+
+    if not active_console.is_terminal:
+        return False
+
+    return _stream_supports_tty(getattr(active_console, "file", None))
+
+
+def _stream_supports_tty(stream: Any) -> bool:
+    """Return True if the provided stream can safely render a spinner."""
+
+    target = stream if hasattr(stream, "isatty") else sys.stdout
+    try:
+        return bool(target.isatty())
+    except Exception:
+        return False
+
+
+def _spinner_update(status_indicator: Any | None, message: str) -> None:
+    """Update spinner text when a status indicator is active."""
+
+    if status_indicator is None:
+        return
+
+    try:
+        status_indicator.update(message)
+    except Exception:  # pragma: no cover - defensive update
+        pass
+
+
+def _spinner_stop(status_indicator: Any | None) -> None:
+    """Stop an active spinner safely."""
+
+    if status_indicator is None:
+        return
+
+    try:
+        status_indicator.stop()
+    except Exception:  # pragma: no cover - defensive stop
+        pass
+
+
 # ----------------------------- Client config ----------------------------- #
 
 
-def get_client(ctx: Any) -> Client:
+def get_client(ctx: Any) -> Client:  # pragma: no cover
     """Get configured client from context, env, and config file (ctx > env > file)."""
     from glaip_sdk import Client
 
@@ -433,7 +508,9 @@ class _FuzzyCompleter:
     def __init__(self, words: list[str]) -> None:
         self.words = words
 
-    def get_completions(self, document: Any, _complete_event: Any) -> Any:
+    def get_completions(
+        self, document: Any, _complete_event: Any
+    ) -> Any:  # pragma: no cover
         word = document.get_word_before_cursor()
         if not word:
             return
@@ -444,7 +521,7 @@ class _FuzzyCompleter:
             if self._fuzzy_match(word_lower, label_lower):
                 yield Completion(label, start_position=-len(word))
 
-    def _fuzzy_match(self, search: str, target: str) -> bool:
+    def _fuzzy_match(self, search: str, target: str) -> bool:  # pragma: no cover
         """True fuzzy matching: checks if all characters in search appear in order in target."""
         if not search:
             return True
@@ -502,47 +579,39 @@ def _fuzzy_pick(
             complete_in_thread=True,
             complete_while_typing=True,
         )
-    except (KeyboardInterrupt, EOFError):
+    except (KeyboardInterrupt, EOFError):  # pragma: no cover - user cancelled input
+        return None
+    except Exception:  # pragma: no cover - prompt_toolkit not available in headless env
         return None
 
     return _perform_fuzzy_search(answer, labels, by_label) if answer else None
 
 
-def _fuzzy_score(search: str, target: str) -> int:
-    """
-    Calculate fuzzy match score.
-    Higher score = better match.
-    Returns -1 if no match possible.
-    """
+def _is_fuzzy_match(search: str, target: str) -> bool:
+    """Check if search string is a fuzzy match for target."""
     if not search:
-        return 0
+        return True
 
-    # Check if it's a fuzzy match first
     search_idx = 0
     for char in target:
         if search_idx < len(search) and search[search_idx] == char:
             search_idx += 1
             if search_idx == len(search):
-                break
+                return True
+    return False
 
-    if search_idx < len(search):
-        return -1  # Not a fuzzy match
 
-    # Calculate score based on:
-    # 1. Exact substring match gets bonus points
-    # 2. Consecutive character matches get bonus points
-    # 3. Shorter search terms get bonus points
+def _calculate_exact_match_bonus(search: str, target: str) -> int:
+    """Calculate bonus for exact substring matches."""
+    return 100 if search.lower() in target.lower() else 0
 
-    score = 0
 
-    # Exact substring bonus
-    if search.lower() in target.lower():
-        score += 100
-
-    # Consecutive character bonus
+def _calculate_consecutive_bonus(search: str, target: str) -> int:
+    """Calculate bonus for consecutive character matches."""
     consecutive = 0
     max_consecutive = 0
     search_idx = 0
+
     for char in target:
         if search_idx < len(search) and search[search_idx] == char:
             consecutive += 1
@@ -551,10 +620,31 @@ def _fuzzy_score(search: str, target: str) -> int:
         else:
             consecutive = 0
 
-    score += max_consecutive * 10
+    return max_consecutive * 10
+
+
+def _calculate_length_bonus(search: str, target: str) -> int:
+    """Calculate bonus for shorter search terms."""
+    return (len(target) - len(search)) * 2
+
+
+def _fuzzy_score(search: str, target: str) -> int:
+    """
+    Calculate fuzzy match score.
+    Higher score = better match.
+    Returns -1 if no match possible.
+    """
+    if not search:
+        return 0
+
+    if not _is_fuzzy_match(search, target):
+        return -1  # Not a fuzzy match
 
-    # Length bonus (shorter searches get higher scores)
-    score += (len(target) - len(search)) * 2
+    # Calculate score based on different factors
+    score = 0
+    score += _calculate_exact_match_bonus(search, target)
+    score += _calculate_consecutive_bonus(search, target)
+    score += _calculate_length_bonus(search, target)
 
     return score
 
@@ -784,11 +874,14 @@ def _handle_fuzzy_pick_selection(
     rows: list[dict[str, Any]], columns: list[tuple], title: str
 ) -> bool:
     """Handle fuzzy picker selection, returns True if selection was made."""
-    picked = (
-        _fuzzy_pick(rows, columns, title)
-        if console.is_terminal and os.isatty(1)
-        else None
-    )
+    picked = None
+    if console.is_terminal and os.isatty(1):
+        try:
+            picked = _fuzzy_pick(rows, columns, title)
+        except Exception:
+            logger.debug(
+                "Fuzzy picker failed; falling back to table output", exc_info=True
+            )
     if picked:
         table = _create_table(columns, title)
         table.add_row(*[str(picked.get(key, "N/A")) for key, _, _, _ in columns])
@@ -1082,6 +1175,7 @@ def resolve_resource(
     label: str,
     select: int | None = None,
     interface_preference: str = "fuzzy",
+    status_indicator: Any | None = None,
 ) -> Any | None:
     """Resolve resource reference (ID or name) with ambiguity handling.
 
@@ -1093,32 +1187,46 @@ def resolve_resource(
         label: Resource type label for error messages
         select: Optional selection index for ambiguity resolution
         interface_preference: "fuzzy" for fuzzy picker, "questionary" for up/down list
+        status_indicator: Optional Rich status indicator for wait animations
 
     Returns:
         Resolved resource object
     """
+    spinner = status_indicator
+    _spinner_update(spinner, f"[bold blue]Resolving {label}…[/bold blue]")
+
     # Try to resolve by ID first
+    _spinner_update(spinner, f"[bold blue]Fetching {label} by ID…[/bold blue]")
     result = _resolve_by_id(ref, get_by_id)
     if result is not None:
+        _spinner_update(spinner, f"[bold green]{label} found[/bold green]")
         return result
 
     # If get_by_id returned None, the resource doesn't exist
     if is_uuid(ref):
+        _spinner_stop(spinner)
         raise click.ClickException(f"{label} '{ref}' not found")
 
     # Find resources by name
+    _spinner_update(
+        spinner, f"[bold blue]Searching {label}s matching '{ref}'…[/bold blue]"
+    )
     matches = find_by_name(name=ref)
     if not matches:
+        _spinner_stop(spinner)
         raise click.ClickException(f"{label} '{ref}' not found")
 
     if len(matches) == 1:
+        _spinner_update(spinner, f"[bold green]{label} found[/bold green]")
         return matches[0]
 
     # Multiple matches found, handle ambiguity
     if select:
+        _spinner_stop(spinner)
         return _resolve_by_name_multiple_with_select(matches, select)
 
     # Choose interface based on preference
+    _spinner_stop(spinner)
     if interface_preference == "fuzzy":
         return _resolve_by_name_multiple_fuzzy(ctx, ref, matches, label)
     else:
@@ -1222,3 +1330,19 @@ def handle_ambiguous_resource(
         else:
             # Re-raise cancellation exceptions
             raise
+
+
+def detect_export_format(file_path: str | Path) -> str:
+    """Detect export format from file extension.
+
+    Args:
+        file_path: Path to the export file
+
+    Returns:
+        "yaml" if file extension is .yaml or .yml, "json" otherwise
+    """
+    path = Path(file_path)
+    if path.suffix.lower() in [".yaml", ".yml"]:
+        return "yaml"
+    else:
+        return "json"

glaip_sdk/client/agents.py

@@ -42,6 +42,9 @@ from glaip_sdk.utils.validation import validate_agent_instruction
 # API endpoints
 AGENTS_ENDPOINT = "/agents/"
 
+# SSE content type
+SSE_CONTENT_TYPE = "text/event-stream"
+
 # Set up module-level logger
 logger = logging.getLogger("glaip_sdk.agents")
 
@@ -519,7 +522,7 @@ class AgentClient(BaseClient):
         Returns:
             Tuple of (payload, data_payload, files_payload, headers, multipart_data)
         """
-        headers = {"Accept": "text/event-stream"}
+        headers = {"Accept": SSE_CONTENT_TYPE}
 
         if files:
             # Handle multipart data for file uploads
@@ -665,10 +668,6 @@ class AgentClient(BaseClient):
             return content
         return final_text
 
-    def _handle_final_response_event(self, ev: dict[str, Any]) -> str:
-        """Handle final response events."""
-        return ev.get("content", "")
-
     def _handle_usage_event(
         self, ev: dict[str, Any], stats_usage: dict[str, Any]
     ) -> None:
@@ -708,11 +707,11 @@ class AgentClient(BaseClient):
         if kind == "artifact":
             return final_text, stats_usage
 
-        # Accumulate assistant content
-        if ev.get("content"):
+        # Handle different event types
+        if kind == "final_response" and ev.get("content"):
+            final_text = ev.get("content", "")
+        elif ev.get("content"):
             final_text = self._handle_content_event(ev, final_text)
-        elif kind == "final_response" and ev.get("content"):
-            final_text = self._handle_final_response_event(ev)
         elif kind == "usage":
             self._handle_usage_event(ev, stats_usage)
         elif kind == "run_info":
@@ -844,6 +843,75 @@ class AgentClient(BaseClient):
         r.on_complete(st)
         return final_payload
 
+    def _prepare_request_data(
+        self,
+        message: str,
+        files: list[str | BinaryIO] | None,
+        **kwargs,
+    ) -> tuple[dict | None, dict | None, dict | None, dict | None]:
+        """Prepare request data for async agent runs.
+
+        Returns:
+            Tuple of (payload, data_payload, files_payload, headers)
+        """
+        if files:
+            # Handle multipart data for file uploads
+            multipart_data = prepare_multipart_data(message, files)
+            # Inject optional multipart extras expected by backend
+            if "chat_history" in kwargs and kwargs["chat_history"] is not None:
+                multipart_data.data["chat_history"] = kwargs["chat_history"]
+            if "pii_mapping" in kwargs and kwargs["pii_mapping"] is not None:
+                multipart_data.data["pii_mapping"] = kwargs["pii_mapping"]
+
+            headers = {"Accept": SSE_CONTENT_TYPE}
+            return None, multipart_data.data, multipart_data.files, headers
+        else:
+            # Simple JSON payload for text-only requests
+            payload = {"input": message, "stream": True, **kwargs}
+            headers = {"Accept": SSE_CONTENT_TYPE}
+            return payload, None, None, headers
+
+    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:
+            config["headers"] = {**config["headers"], **headers}
+        return config
+
+    async def _stream_agent_response(
+        self,
+        async_client: httpx.AsyncClient,
+        agent_id: str,
+        payload: dict | None,
+        data_payload: dict | None,
+        files_payload: dict | None,
+        headers: dict | None,
+        timeout_seconds: float,
+        agent_name: str | None,
+    ) -> AsyncGenerator[dict, None]:
+        """Stream the agent response and yield parsed JSON chunks."""
+        async with async_client.stream(
+            "POST",
+            f"/agents/{agent_id}/run",
+            json=payload,
+            data=data_payload,
+            files=files_payload,
+            headers=headers,
+        ) as stream_response:
+            stream_response.raise_for_status()
+
+            async for event in aiter_sse_events(
+                stream_response, timeout_seconds, agent_name
+            ):
+                try:
+                    chunk = json.loads(event["data"])
+                    yield chunk
+                except json.JSONDecodeError:
+                    logger.debug("Non-JSON SSE fragment skipped")
+                    continue
+
     async def arun_agent(
         self,
         agent_id: str,
@@ -870,74 +938,34 @@ class AgentClient(BaseClient):
             httpx.TimeoutException: When general timeout occurs
             Exception: For other unexpected errors
         """
-        # Prepare multipart data if files are provided
-        multipart_data = None
-        headers = None  # None means "don't override client defaults"
-
-        if files:
-            multipart_data = prepare_multipart_data(message, files)
-            # Inject optional multipart extras expected by backend
-            if "chat_history" in kwargs and kwargs["chat_history"] is not None:
-                multipart_data.data["chat_history"] = kwargs["chat_history"]
-            if "pii_mapping" in kwargs and kwargs["pii_mapping"] is not None:
-                multipart_data.data["pii_mapping"] = kwargs["pii_mapping"]
-            headers = None  # Let httpx set proper multipart boundaries
+        # Prepare request data
+        payload, data_payload, files_payload, headers = self._prepare_request_data(
+            message, files, **kwargs
+        )
 
-        # When streaming, explicitly prefer SSE
-        headers = {**(headers or {}), "Accept": "text/event-stream"}
+        # Create async client configuration
+        async_client_config = self._create_async_client_config(timeout, headers)
 
-        if files:
-            payload = None
-            # Use multipart data
-            data_payload = multipart_data.data
-            files_payload = multipart_data.files
-        else:
-            payload = {"input": message, **kwargs}
-            # Explicitly send stream intent both ways
-            payload["stream"] = True
-            data_payload = None
-            files_payload = None
-
-        # Use timeout from parameter or instance default
-        request_timeout = timeout or self.timeout
+        # Get execution timeout for streaming control
+        timeout_seconds = kwargs.get("timeout", DEFAULT_AGENT_RUN_TIMEOUT)
+        agent_name = kwargs.get("agent_name")
 
         try:
-            async_client_config = self._build_async_client(request_timeout)
-            if headers:
-                async_client_config["headers"] = {
-                    **async_client_config["headers"],
-                    **headers,
-                }
-
-            # Create async client for this request
+            # Create async client and stream response
             async with httpx.AsyncClient(**async_client_config) as async_client:
-                async with async_client.stream(
-                    "POST",
-                    f"/agents/{agent_id}/run",
-                    json=payload,
-                    data=data_payload,
-                    files=files_payload,
-                    headers=headers,
-                ) as stream_response:
-                    stream_response.raise_for_status()
-
-                    # Get agent run timeout for execution control
-                    # Prefer parameter timeout, otherwise use default
-                    timeout_seconds = kwargs.get("timeout", DEFAULT_AGENT_RUN_TIMEOUT)
-
-                    agent_name = kwargs.get("agent_name")
-
-                    async for event in aiter_sse_events(
-                        stream_response, timeout_seconds, agent_name
-                    ):
-                        try:
-                            chunk = json.loads(event["data"])
-                            yield chunk
-                        except json.JSONDecodeError:
-                            logger.debug("Non-JSON SSE fragment skipped")
-                            continue
+                async for chunk in self._stream_agent_response(
+                    async_client,
+                    agent_id,
+                    payload,
+                    data_payload,
+                    files_payload,
+                    headers,
+                    timeout_seconds,
+                    agent_name,
+                ):
+                    yield chunk
 
         finally:
-            # Ensure we close any opened file handles from multipart
-            if multipart_data:
-                multipart_data.close()
+            # Ensure cleanup - this is handled by the calling context
+            # but we keep this for safety in case of future changes
+            pass

glaip_sdk/client/base.py

@@ -254,25 +254,25 @@ class BaseClient:
                 client_log.error(f"Retry failed for {method} {endpoint}: {e}")
                 raise e
 
-    def _handle_response(self, response: httpx.Response) -> Any:
-        """Handle HTTP response with proper error handling."""
+    def _parse_response_content(self, response: httpx.Response) -> Any | None:
+        """Parse response content based on content type."""
         if response.status_code == 204:
             return None
 
-        parsed = None
         content_type = response.headers.get("content-type", "").lower()
         if "json" in content_type:
             try:
-                parsed = response.json()
+                return response.json()
             except ValueError:
                 pass
 
-        if parsed is None:
-            if 200 <= response.status_code < 300:
-                return response.text
-            else:
-                self._raise_api_error(response.status_code, response.text)
+        if 200 <= response.status_code < 300:
+            return response.text
+        else:
+            return None  # Let _handle_response deal with error status codes
 
+    def _handle_success_response(self, parsed: Any) -> Any:
+        """Handle successful response with success flag."""
         if isinstance(parsed, dict) and "success" in parsed:
             if parsed.get("success"):
                 return parsed.get("data", parsed)
@@ -280,14 +280,45 @@ class BaseClient:
                 error_type = parsed.get("error", "UnknownError")
                 message = parsed.get("message", "Unknown error")
                 self._raise_api_error(
-                    response.status_code, message, error_type, payload=parsed
+                    400,
+                    message,
+                    error_type,
+                    payload=parsed,  # Using 400 as status since original response had error
                 )
 
-        if 200 <= response.status_code < 300:
-            return parsed
+        return parsed
+
+    def _get_error_message(self, response: httpx.Response) -> str:
+        """Extract error message from response, preferring parsed content."""
+        # Try to get error message from parsed content if available
+        error_message = response.text
+        try:
+            parsed = response.json()
+            if isinstance(parsed, dict) and "message" in parsed:
+                error_message = parsed["message"]
+            elif isinstance(parsed, str):
+                error_message = parsed
+        except (ValueError, TypeError):
+            pass  # Use response.text as fallback
+        return error_message
+
+    def _handle_response(self, response: httpx.Response) -> Any:
+        """Handle HTTP response with proper error handling."""
+        # Handle no-content success before general error handling
+        if response.status_code == 204:
+            return None
+
+        # Handle error status codes
+        if not (200 <= response.status_code < 300):
+            error_message = self._get_error_message(response)
+            self._raise_api_error(response.status_code, error_message)
+            return None  # Won't be reached but helps with type checking
+
+        parsed = self._parse_response_content(response)
+        if parsed is None:
+            return None
 
-        message = parsed.get("message") if isinstance(parsed, dict) else str(parsed)
-        self._raise_api_error(response.status_code, message, payload=parsed)
+        return self._handle_success_response(parsed)
 
     def _raise_api_error(
         self,