glaip-sdk 0.6.12__py3-none-any.whl → 0.6.15__py3-none-any.whl

glaip_sdk/utils/discovery.py

@@ -1,78 +0,0 @@
-"""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

@@ -1,135 +0,0 @@
-"""Rich display utilities for enhanced output.
-
-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
-from glaip_sdk.icons import ICON_AGENT
-
-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 AIPanel
-else:  # pragma: no cover - runtime fallback for type checking
-    AIPanel = Any  # type: ignore[assignment]
-
-
-def _check_rich_available() -> bool:
-    """Return True when core Rich display dependencies are importable."""
-    try:
-        __import__("rich.console")
-        __import__("rich.text")
-        __import__("glaip_sdk.rich_components")
-    except Exception:
-        return False
-    return True
-
-
-RICH_AVAILABLE = _check_rich_available()
-
-
-def _create_console() -> Console:
-    """Return a Console instance with lazy import to ease mocking."""
-    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:
-    """Return a Text instance with lazy import to ease mocking."""
-    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)
-
-
-def _create_panel(*args: Any, **kwargs: Any) -> AIPanel:
-    """Return an AIPPanel instance with lazy import to ease mocking."""
-    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:
-    """Print agent output with rich formatting.
-
-    Args:
-        output: The agent's response text
-        title: Title for the output panel
-    """
-    if RICH_AVAILABLE:
-        console = _create_console()
-        panel = _create_panel(
-            _create_text(output, style=SUCCESS),
-            title=title,
-            border_style=SUCCESS,
-        )
-        console.print(panel)
-    else:
-        print(f"\n=== {title} ===")
-        print(output)
-        print("=" * (len(title) + 8))
-
-
-def print_agent_created(agent: Any, title: str = f"{ICON_AGENT} Agent Created") -> None:
-    """Print agent creation success with rich formatting.
-
-    Args:
-        agent: The created agent object
-        title: Title for the output panel
-    """
-    if RICH_AVAILABLE:
-        console = _create_console()
-        panel = _create_panel(
-            f"[{SUCCESS_STYLE}]✅ Agent '{agent.name}' created successfully![/]\n\n"
-            f"ID: {agent.id}\n"
-            f"Model: {getattr(agent, 'model', 'N/A')}\n"
-            f"Type: {getattr(agent, 'type', 'config')}\n"
-            f"Framework: {getattr(agent, 'framework', 'langchain')}\n"
-            f"Version: {getattr(agent, 'version', '1.0')}",
-            title=title,
-            border_style=SUCCESS,
-        )
-        console.print(panel)
-    else:
-        print(f"✅ Agent '{agent.name}' created successfully!")
-        print(f"ID: {agent.id}")
-        print(f"Model: {getattr(agent, 'model', 'N/A')}")
-        print(f"Type: {getattr(agent, 'type', 'config')}")
-        print(f"Framework: {getattr(agent, 'framework', 'langchain')}")
-        print(f"Version: {getattr(agent, 'version', '1.0')}")
-
-
-def print_agent_updated(agent: Any) -> None:
-    """Print agent update success with rich formatting.
-
-    Args:
-        agent: The updated agent object
-    """
-    if RICH_AVAILABLE:
-        console = _create_console()
-        console.print(f"[{SUCCESS_STYLE}]✅ Agent '{agent.name}' updated successfully[/]")
-    else:
-        print(f"✅ Agent '{agent.name}' updated successfully")
-
-
-def print_agent_deleted(agent_id: str) -> None:
-    """Print agent deletion success with rich formatting.
-
-    Args:
-        agent_id: The deleted agent's ID
-    """
-    if RICH_AVAILABLE:
-        console = _create_console()
-        console.print(f"[{SUCCESS_STYLE}]✅ Agent deleted successfully (ID: {agent_id})[/]")
-    else:
-        print(f"✅ Agent deleted successfully (ID: {agent_id})")

glaip_sdk/utils/export.py

@@ -1,143 +0,0 @@
-#!/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

@@ -1,61 +0,0 @@
-"""General utility functions for AIP SDK.
-
-Authors:
-    Raymond Christopher (raymond.christopher@gdplabs.id)
-"""
-
-from collections.abc import Iterable, Iterator
-from datetime import datetime
-from typing import Any
-
-import click
-
-
-def format_file_size(size_bytes: int) -> str:
-    """Format file size in human readable format.
-
-    Args:
-        size_bytes: Size in bytes
-
-    Returns:
-        Human readable size string (e.g., "1.5 MB")
-    """
-    for unit in ["B", "KB", "MB", "GB"]:
-        if size_bytes < 1024.0:
-            return f"{size_bytes:.1f} {unit}"
-        size_bytes /= 1024.0
-    return f"{size_bytes:.1f} TB"
-
-
-def format_datetime(dt: datetime | str | None) -> str:
-    """Format datetime object to readable string.
-
-    Args:
-        dt: Datetime object or string to format
-
-    Returns:
-        Formatted datetime string or "N/A" if None
-    """
-    if isinstance(dt, datetime):
-        return dt.strftime("%Y-%m-%d %H:%M:%S UTC")
-    elif dt is None:
-        return "N/A"
-    return str(dt)
-
-
-def progress_bar(iterable: Iterable[Any], description: str = "Processing") -> Iterator[Any]:
-    """Simple progress bar using click.
-
-    Args:
-        iterable: Iterable to process
-        description: Progress description
-
-    Yields:
-        Items from iterable with progress display
-    """
-    try:
-        with click.progressbar(iterable, label=description) as bar:
-            yield from bar
-    except ImportError:
-        # Fallback if click not available
-        yield from iterable

glaip_sdk/utils/import_export.py

@@ -1,168 +0,0 @@
-"""Import/export utilities for schema transforms and data merging.
-
-This module provides functions for converting between export and import formats,
-merging imported data with CLI arguments, and handling relationship flattening.
-
-Authors:
-    Raymond Christopher (raymond.christopher@gdplabs.id)
-"""
-
-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)
-
-    Returns:
-        List of extracted IDs (only items with actual IDs)
-
-    Examples:
-        extract_ids_from_export([{"id": "123", "name": "tool"}]) -> ["123"]
-        extract_ids_from_export(["123", "456"]) -> ["123", "456"]
-        extract_ids_from_export([{"name": "tool"}, "123"]) -> ["123"]  # Skip items without ID
-    """
-    if not items:
-        return []
-
-    ids = []
-    for item in items:
-        extracted = _extract_id_from_item(item, skip_missing=True)
-        if extracted is not None:
-            ids.append(extracted)
-
-    return ids
-
-
-def convert_export_to_import_format(
-    data: dict[str, Any],
-) -> dict[str, Any]:
-    """Convert export format to import-compatible format (extract IDs from objects).
-
-    Args:
-        data: Export format data with full objects
-
-    Returns:
-        Import format data with extracted IDs
-
-    Notes:
-        - Converts tools/agents from dict objects to ID lists
-        - Preserves all other data unchanged
-    """
-    import_data = data.copy()
-
-    for key in ["tools", "agents", "mcps"]:
-        if key in import_data and isinstance(import_data[key], list):
-            import_data[key] = extract_ids_from_export(import_data[key])
-
-    return import_data
-
-
-def _get_default_array_fields() -> list[str]:
-    """Get default array fields that should be merged."""
-    return ["tools", "agents", "mcps"]
-
-
-def _should_use_cli_value(cli_value: Any) -> bool:
-    """Check if CLI value should be used."""
-    return cli_value is not None and (not isinstance(cli_value, (list, tuple)) or len(cli_value) > 0)
-
-
-def _handle_array_field_merge(key: str, cli_value: Any, import_data: dict[str, Any]) -> Any:
-    """Handle merging of array fields."""
-    import_value = import_data[key]
-    if isinstance(import_value, list):
-        return list(cli_value) + import_value
-    else:
-        return cli_value
-
-
-def _merge_cli_values_with_import(
-    merged: dict[str, Any],
-    cli_args: dict[str, Any],
-    import_data: dict[str, Any],
-    array_fields: list[str],
-) -> None:
-    """Merge CLI values into merged dict."""
-    for key, cli_value in cli_args.items():
-        if _should_use_cli_value(cli_value):
-            # CLI value takes precedence (for non-empty values)
-            if key in array_fields and key in import_data:
-                # For array fields, combine CLI and imported values
-                merged[key] = _handle_array_field_merge(key, cli_value, import_data)
-            else:
-                merged[key] = cli_value
-        elif key in import_data:
-            # Use imported value if no CLI value
-            merged[key] = import_data[key]
-
-
-def _add_import_only_fields(merged: dict[str, Any], import_data: dict[str, Any]) -> None:
-    """Add fields that exist only in import data."""
-    for key, import_value in import_data.items():
-        if key not in merged:
-            merged[key] = import_value
-
-
-def merge_import_with_cli_args(
-    import_data: dict[str, Any],
-    cli_args: dict[str, Any],
-    array_fields: list[str] = None,
-) -> dict[str, Any]:
-    """Merge imported data with CLI arguments, preferring CLI args.
-
-    Args:
-        import_data: Data loaded from import file
-        cli_args: Arguments passed via CLI
-        array_fields: Fields that should be combined (merged) rather than replaced
-
-    Returns:
-        Merged data dictionary
-
-    Notes:
-        - CLI arguments take precedence over imported data
-        - Array fields (tools, agents, mcps) are combined rather than replaced
-        - Empty arrays/lists are treated as None (no override)
-    """
-    if array_fields is None:
-        array_fields = _get_default_array_fields()
-
-    merged = {}
-    _merge_cli_values_with_import(merged, cli_args, import_data, array_fields)
-    _add_import_only_fields(merged, import_data)
-
-    return merged
-
-
-def flatten_relationships_for_import(
-    data: dict[str, Any], fields: tuple[str, ...] = ("tools", "agents")
-) -> dict[str, Any]:
-    """Flatten relationship fields for import format.
-
-    This is an alias for convert_export_to_import_format with configurable fields.
-
-    Args:
-        data: Export format data with full objects
-        fields: Tuple of field names to flatten to IDs
-
-    Returns:
-        Import format data with specified fields flattened to IDs
-    """
-    import_data = data.copy()
-
-    for field in fields:
-        if field in import_data and isinstance(import_data[field], list):
-            import_data[field] = extract_ids_from_export(import_data[field])
-
-    return import_data