glaip-sdk 0.1.3__py3-none-any.whl → 0.6.10__py3-none-any.whl

glaip_sdk/utils/discovery.py

@@ -0,0 +1,78 @@
+"""Agent and tool discovery functions.
+
+This module provides functions for finding agents and tools
+from the GLAIP backend.
+
+Authors:
+    Christian Trisno Sen Long Chen (christian.t.s.l.chen@gdplabs.id)
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from gllm_core.utils import LoggerManager
+
+if TYPE_CHECKING:
+    from glaip_sdk.agents import Agent
+    from glaip_sdk.tools import Tool
+
+logger = LoggerManager().get_logger(__name__)
+
+
+def find_agent(name: str) -> Agent | None:
+    """Find an agent by name using GLAIP SDK.
+
+    Args:
+        name: The name of the agent to find.
+
+    Returns:
+        The agent if found, None otherwise.
+
+    Example:
+        >>> from glaip_sdk.utils.discovery import find_agent
+        >>> agent = find_agent("weather_reporter")
+        >>> if agent:
+        ...     print(f"Found agent: {agent.name}")
+    """
+    from glaip_sdk.utils.client import get_client  # noqa: PLC0415
+
+    client = get_client()
+    try:
+        agents = client.list_agents()
+        for agent in agents:
+            if agent.name == name:
+                return agent
+        return None
+    except Exception as e:
+        logger.error("Error finding agent '%s': %s", name, e)
+        return None
+
+
+def find_tool(name: str) -> Tool | None:
+    """Find a tool by name using GLAIP SDK.
+
+    Args:
+        name: The name of the tool to find.
+
+    Returns:
+        The tool if found, None otherwise.
+
+    Example:
+        >>> from glaip_sdk.utils.discovery import find_tool
+        >>> tool = find_tool("weather_api")
+        >>> if tool:
+        ...     print(f"Found tool: {tool.name}")
+    """
+    from glaip_sdk.utils.client import get_client  # noqa: PLC0415
+
+    client = get_client()
+    try:
+        tools = client.find_tools(name)
+        for tool in tools:
+            if tool.name == name:
+                return tool
+        return None
+    except Exception as e:
+        logger.error("Error finding tool '%s': %s", name, e)
+        return None

glaip_sdk/utils/display.py

@@ -4,6 +4,9 @@ Authors:
     Raymond Christopher (raymond.christopher@gdplabs.id)
 """
 
+from __future__ import annotations
+
+from importlib import import_module
 from typing import TYPE_CHECKING, Any
 
 from glaip_sdk.branding import SUCCESS, SUCCESS_STYLE
@@ -13,42 +16,47 @@ if TYPE_CHECKING:  # pragma: no cover - import-time typing helpers
     from rich.console import Console
     from rich.text import Text
 
-    from glaip_sdk.rich_components import AIPPanel
+    from glaip_sdk.rich_components import AIPanel
+else:  # pragma: no cover - runtime fallback for type checking
+    AIPanel = Any  # type: ignore[assignment]
 
 
 def _check_rich_available() -> bool:
-    """Check if Rich and our custom components can be imported."""
+    """Return True when core Rich display dependencies are importable."""
     try:
         __import__("rich.console")
         __import__("rich.text")
         __import__("glaip_sdk.rich_components")
-        return True
     except Exception:
         return False
+    return True
 
 
 RICH_AVAILABLE = _check_rich_available()
 
 
-def _create_console() -> "Console":
+def _create_console() -> Console:
     """Return a Console instance with lazy import to ease mocking."""
-    from rich.console import Console  # Local import for test friendliness
-
-    return Console()
+    if not RICH_AVAILABLE:  # pragma: no cover - defensive guard
+        raise RuntimeError("Rich Console is not available")
+    console_module = import_module("rich.console")
+    return console_module.Console()
 
 
-def _create_text(*args: Any, **kwargs: Any) -> "Text":
+def _create_text(*args: Any, **kwargs: Any) -> Text:
     """Return a Text instance with lazy import to ease mocking."""
-    from rich.text import Text  # Local import for test friendliness
+    if not RICH_AVAILABLE:  # pragma: no cover - defensive guard
+        raise RuntimeError("Rich Text is not available")
+    text_module = import_module("rich.text")
+    return text_module.Text(*args, **kwargs)
 
-    return Text(*args, **kwargs)
 
-
-def _create_panel(*args: Any, **kwargs: Any) -> "AIPPanel":
+def _create_panel(*args: Any, **kwargs: Any) -> AIPanel:
     """Return an AIPPanel instance with lazy import to ease mocking."""
-    from glaip_sdk.rich_components import AIPPanel  # Local import for test friendliness
-
-    return AIPPanel(*args, **kwargs)
+    if not RICH_AVAILABLE:  # pragma: no cover - defensive guard
+        raise RuntimeError("AIPPanel is not available")
+    components = import_module("glaip_sdk.rich_components")
+    return components.AIPPanel(*args, **kwargs)
 
 
 def print_agent_output(output: str, title: str = "Agent Output") -> None:

glaip_sdk/utils/export.py

@@ -0,0 +1,143 @@
+#!/usr/bin/env python3
+"""Export utilities for remote agent run transcripts.
+
+Authors:
+    Raymond Christopher (raymond.christopher@gdplabs.id)
+"""
+
+import json
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+from glaip_sdk.models.agent_runs import RunWithOutput, RunOutputChunk
+
+
+def export_remote_transcript_jsonl(
+    run: RunWithOutput,
+    destination: Path,
+    *,
+    overwrite: bool = False,
+    agent_name: str | None = None,
+    model: str | None = None,
+) -> Path:
+    """Export a remote run transcript to JSONL format compatible with local transcript viewers.
+
+    Args:
+        run: RunWithOutput instance to export
+        destination: Target file path for JSONL export
+        overwrite: Whether to overwrite existing file
+        agent_name: Optional agent name for metadata
+        model: Optional model name for metadata (extracted from run.config if not provided)
+
+    Returns:
+        Path to the exported file
+
+    Raises:
+        FileExistsError: If destination exists and overwrite is False
+        OSError: If file cannot be written
+    """
+    if destination.exists() and not overwrite:
+        raise FileExistsError(f"File already exists: {destination}")
+
+    # Ensure parent directory exists
+    destination.parent.mkdir(parents=True, exist_ok=True)
+
+    model_name = model or _extract_model(run)
+    final_output_text = _extract_final_output(run.output) or ""
+
+    meta_payload = _build_meta_payload(run, agent_name, model_name)
+    meta_record = _build_meta_record(run, agent_name, model_name, final_output_text, meta_payload)
+
+    _write_jsonl_file(destination, meta_record, run.output)
+
+    return destination
+
+
+def _build_meta_payload(run: RunWithOutput, agent_name: str | None, model_name: str | None) -> dict[str, Any]:
+    """Build the meta payload dictionary."""
+    return {
+        "agent_name": agent_name,
+        "model": model_name,
+        "input_message": run.input,
+        "status": run.status,
+        "run_type": run.run_type,
+        "schedule_id": str(run.schedule_id) if run.schedule_id else None,
+        "config": run.config or {},
+        "created_at": run.created_at.isoformat() if run.created_at else None,
+        "updated_at": run.updated_at.isoformat() if run.updated_at else None,
+        "event_count": len(run.output),
+    }
+
+
+def _build_meta_record(
+    run: RunWithOutput,
+    agent_name: str | None,
+    model_name: str | None,
+    final_output_text: str,
+    meta_payload: dict[str, Any],
+) -> dict[str, Any]:
+    """Build the meta record dictionary."""
+    return {
+        "type": "meta",
+        "run_id": str(run.id),
+        "agent_id": str(run.agent_id),
+        "agent_name": agent_name,
+        "model": model_name,
+        "created_at": run.created_at.isoformat() if run.created_at else None,
+        "default_output": final_output_text,
+        "final_output": final_output_text,
+        "server_run_id": str(run.id),
+        "started_at": run.started_at.isoformat() if run.started_at else None,
+        "finished_at": run.completed_at.isoformat() if run.completed_at else None,
+        "meta": meta_payload,
+        "source": "remote_history",
+        # Back-compat fields used by older tooling
+        "run_type": run.run_type,
+        "schedule_id": str(run.schedule_id) if run.schedule_id else None,
+        "status": run.status,
+        "input": run.input,
+        "config": run.config or {},
+        "updated_at": run.updated_at.isoformat() if run.updated_at else None,
+    }
+
+
+def _write_jsonl_file(destination: Path, meta_record: dict[str, Any], events: list[RunOutputChunk]) -> None:
+    """Write the JSONL file with meta and event records."""
+    records: list[dict[str, Any]] = [meta_record]
+    records.extend({"type": "event", "event": event} for event in events)
+
+    with destination.open("w", encoding="utf-8") as fh:
+        for idx, record in enumerate(records):
+            json.dump(record, fh, ensure_ascii=False, indent=2, default=_json_default)
+            fh.write("\n")
+            if idx != len(records) - 1:
+                fh.write("\n")
+
+
+def _extract_model(run: RunWithOutput) -> str | None:
+    """Best-effort extraction of the model name from run metadata."""
+    config = run.config or {}
+    if isinstance(config, dict):
+        model = config.get("model") or config.get("llm", {}).get("model")
+        if isinstance(model, str):
+            return model
+    return None
+
+
+def _extract_final_output(events: list[RunOutputChunk]) -> str | None:
+    """Return the final response content from the event stream."""
+    for chunk in reversed(events):
+        content = chunk.get("content")
+        if not content:
+            continue
+        if chunk.get("event_type") == "final_response" or chunk.get("final"):
+            return str(content)
+    return None
+
+
+def _json_default(obj: Any) -> Any:
+    """JSON serializer for datetime objects."""
+    if isinstance(obj, datetime):
+        return obj.isoformat()
+    raise TypeError(f"Type {type(obj)} not serializable")

glaip_sdk/utils/general.py

@@ -4,46 +4,13 @@ Authors:
     Raymond Christopher (raymond.christopher@gdplabs.id)
 """
 
-import re
 from collections.abc import Iterable, Iterator
 from datetime import datetime
 from typing import Any
-from uuid import UUID
 
 import click
 
 
-def is_uuid(value: str) -> bool:
-    """Check if a string is a valid UUID.
-
-    Args:
-        value: String to check
-
-    Returns:
-        True if value is a valid UUID, False otherwise
-    """
-    try:
-        UUID(value)
-        return True
-    except (ValueError, TypeError):
-        return False
-
-
-def sanitize_name(name: str) -> str:
-    """Sanitize a name for resource creation.
-
-    Args:
-        name: Raw name input
-
-    Returns:
-        Sanitized name suitable for resource creation
-    """
-    # Remove special characters and normalize
-    sanitized = re.sub(r"[^a-zA-Z0-9\-_]", "-", name.strip())
-    sanitized = re.sub(r"-+", "-", sanitized)  # Collapse multiple dashes
-    return sanitized.lower().strip("-")
-
-
 def format_file_size(size_bytes: int) -> str:
     """Format file size in human readable format.
 

glaip_sdk/utils/import_export.py

@@ -9,10 +9,19 @@ Authors:
 
 from typing import Any
 
+from glaip_sdk.utils.resource_refs import _extract_id_from_item
+
 
 def extract_ids_from_export(items: list[Any]) -> list[str]:
     """Extract IDs from export format (list of dicts with id/name fields).
 
+    This function is similar to `extract_ids` in `resource_refs.py` but differs in behavior:
+    - This function SKIPS items without IDs (doesn't convert to string)
+    - `extract_ids` converts items without IDs to strings as fallback
+
+    This difference is intentional: export format should only include actual IDs,
+    while general resource reference extraction may need fallback string conversion.
+
     Args:
         items: List of items (dicts with id/name or strings)
 
@@ -29,13 +38,9 @@ def extract_ids_from_export(items: list[Any]) -> list[str]:
 
     ids = []
     for item in items:
-        if isinstance(item, str):
-            ids.append(item)
-        elif hasattr(item, "id"):
-            ids.append(str(item.id))
-        elif isinstance(item, dict) and "id" in item:
-            ids.append(str(item["id"]))
-        # Skip items without ID (don't convert to string)
+        extracted = _extract_id_from_item(item, skip_missing=True)
+        if extracted is not None:
+            ids.append(extracted)
 
     return ids