glaip-sdk 0.6.5b6__py3-none-any.whl → 0.7.12__py3-none-any.whl

glaip_sdk/cli/commands/agents/delete.py

@@ -0,0 +1,64 @@
+"""Delete agent command.
+
+Authors:
+    Raymond Christopher (raymond.christopher@gdplabs.id)
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import click
+
+from glaip_sdk.cli.context import output_flags
+from glaip_sdk.cli.display import (
+    display_confirmation_prompt,
+    display_deletion_success,
+    handle_json_output,
+    handle_rich_output,
+)
+from glaip_sdk.cli.core.context import get_client
+
+from ._common import (
+    _handle_click_exception_for_json,
+    _handle_command_exception,
+    agents_group,
+)
+
+
+@agents_group.command()
+@click.argument("agent_id")
+@click.option("-y", "--yes", is_flag=True, help="Skip confirmation")
+@output_flags()
+@click.pass_context
+def delete(ctx: Any, agent_id: str, yes: bool) -> None:
+    """Delete an agent."""
+    try:
+        client = get_client(ctx)
+
+        # Get agent by ID (no ambiguity handling needed)
+        try:
+            agent = client.agents.get_agent_by_id(agent_id)
+        except Exception as e:
+            raise click.ClickException(f"Agent with ID '{agent_id}' not found: {e}") from e
+
+        # Confirm deletion when not forced
+        if not yes:
+            if not display_confirmation_prompt("Agent", agent.name):
+                return
+
+        client.agents.delete_agent(agent.id)
+
+        handle_json_output(
+            ctx,
+            {
+                "success": True,
+                "message": f"Agent '{agent.name}' deleted",
+            },
+        )
+        handle_rich_output(ctx, display_deletion_success("Agent", agent.name))
+
+    except click.ClickException as e:
+        _handle_click_exception_for_json(ctx, e)
+    except Exception as e:
+        _handle_command_exception(ctx, e)

glaip_sdk/cli/commands/agents/get.py

@@ -0,0 +1,89 @@
+"""Get agent command.
+
+Authors:
+    Raymond Christopher (raymond.christopher@gdplabs.id)
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+import click
+
+from glaip_sdk.cli.context import output_flags
+from glaip_sdk.cli.display import display_agent_run_suggestions, handle_rich_output
+from glaip_sdk.cli.core.context import get_client
+from glaip_sdk.cli.core.output import handle_resource_export
+
+from ._common import _display_agent_details, _resolve_agent, agents_group, console
+
+
+@agents_group.command()
+@click.argument("agent_ref")
+@click.option("--select", type=int, help="Choose among ambiguous matches (1-based)")
+@click.option(
+    "--export",
+    type=click.Path(dir_okay=False, writable=True),
+    help="Export complete agent configuration to file (format auto-detected from .json/.yaml extension)",
+)
+@click.option(
+    "--instruction-preview",
+    type=int,
+    default=0,
+    show_default=True,
+    help="Instruction preview length when printing instructions (0 shows full prompt).",
+)
+@output_flags()
+@click.pass_context
+def get(
+    ctx: Any,
+    agent_ref: str,
+    select: int | None,
+    export: str | None,
+    instruction_preview: int,
+) -> None:
+    r"""Get agent details.
+
+    \b
+    Examples:
+        aip agents get my-agent
+        aip agents get my-agent --export agent.json    # Exports complete configuration as JSON
+        aip agents get my-agent --export agent.yaml    # Exports complete configuration as YAML
+    """
+    try:
+        # Initialize API client for agent retrieval
+        api_client = get_client(ctx)
+
+        # Resolve agent reference using questionary interface for better UX
+        agent = _resolve_agent(ctx, api_client, agent_ref, select, interface_preference="questionary")
+
+        if not agent:
+            raise click.ClickException(f"Agent '{agent_ref}' not found")
+
+        # Handle export option if requested
+        if export:
+            handle_resource_export(
+                ctx,
+                agent,
+                Path(export),
+                resource_type="agent",
+                get_by_id_func=api_client.agents.get_agent_by_id,
+                console_override=console,
+            )
+
+        # Display full agent details using the standardized helper
+        _display_agent_details(
+            ctx,
+            api_client,
+            agent,
+            instruction_preview_limit=instruction_preview,
+        )
+
+        # Show run suggestions via centralized display helper
+        handle_rich_output(ctx, display_agent_run_suggestions(agent))
+
+    except click.ClickException:
+        raise
+    except Exception as e:
+        raise click.ClickException(str(e)) from e

glaip_sdk/cli/commands/agents/list.py

@@ -0,0 +1,129 @@
+"""List agents command.
+
+Authors:
+    Raymond Christopher (raymond.christopher@gdplabs.id)
+"""
+
+from __future__ import annotations
+
+import os
+from typing import Any
+
+import click
+
+from glaip_sdk.branding import ACCENT_STYLE, INFO, SUCCESS, WARNING_STYLE
+from glaip_sdk.cli.context import output_flags
+from glaip_sdk.cli.display import display_agent_run_suggestions, handle_rich_output
+from glaip_sdk.cli.core.output import coerce_to_row, output_list
+from glaip_sdk.cli.core.prompting import _fuzzy_pick_for_resources
+from glaip_sdk.cli.core.rendering import with_client_and_spinner
+from glaip_sdk.icons import ICON_AGENT
+
+from ._common import _display_agent_details, agents_group, console
+
+
+@agents_group.command(name="list")
+@click.option("--simple", is_flag=True, help="Show simple table without interactive picker")
+@click.option("--type", "agent_type", help="Filter by agent type (config, code, a2a, langflow)")
+@click.option("--framework", help="Filter by framework (langchain, langgraph, google_adk)")
+@click.option("--name", help="Filter by partial name match (case-insensitive)")
+@click.option("--version", help="Filter by exact version match")
+@click.option(
+    "--sync-langflow",
+    is_flag=True,
+    help="Sync with LangFlow server before listing (only applies when filtering by langflow type)",
+)
+@output_flags()
+@click.pass_context
+def list_agents(
+    ctx: Any,
+    simple: bool,
+    agent_type: str | None,
+    framework: str | None,
+    name: str | None,
+    version: str | None,
+    sync_langflow: bool,
+) -> None:
+    """List agents with optional filtering."""
+    try:
+        with with_client_and_spinner(
+            ctx,
+            "[bold blue]Fetching agents…[/bold blue]",
+            console_override=console,
+        ) as client:
+            # Query agents with specified filters
+            filter_params = {
+                "agent_type": agent_type,
+                "framework": framework,
+                "name": name,
+                "version": version,
+                "sync_langflow_agents": sync_langflow,
+            }
+            agents = client.agents.list_agents(**filter_params)
+
+        # Define table columns: (data_key, header, style, width)
+        columns = [
+            ("id", "ID", "dim", 36),
+            ("name", "Name", ACCENT_STYLE, None),
+            ("type", "Type", WARNING_STYLE, None),
+            ("framework", "Framework", INFO, None),
+            ("version", "Version", SUCCESS, None),
+        ]
+
+        # Transform function for safe attribute access
+        def transform_agent(agent: Any) -> dict[str, Any]:
+            """Transform an agent object to a display row dictionary.
+
+            Args:
+                agent: Agent object to transform.
+
+            Returns:
+                Dictionary with id, name, type, framework, and version fields.
+            """
+            row = coerce_to_row(agent, ["id", "name", "type", "framework", "version"])
+            # Ensure id is always a string
+            row["id"] = str(row["id"])
+            return row
+
+        # Use fuzzy picker for interactive agent selection and details (default behavior)
+        # Skip if --simple flag is used, a name filter is applied, or non-rich output is requested
+        ctx_obj = ctx.obj if isinstance(getattr(ctx, "obj", None), dict) else {}
+        current_view = ctx_obj.get("view")
+        interactive_enabled = (
+            not simple
+            and name is None
+            and current_view not in {"json", "plain", "md"}
+            and console.is_terminal
+            and os.isatty(1)
+            and len(agents) > 0
+        )
+
+        # Track picker attempt so the fallback table doesn't re-open the palette
+        picker_attempted = False
+        if interactive_enabled:
+            picker_attempted = True
+            picked_agent = _fuzzy_pick_for_resources(agents, "agent", "")
+            if picked_agent:
+                _display_agent_details(ctx, client, picked_agent)
+                # Show run suggestions via centralized display helper
+                handle_rich_output(ctx, display_agent_run_suggestions(picked_agent))
+                return
+
+        # Show simple table (either --simple flag or non-interactive)
+        output_list(
+            ctx,
+            agents,
+            f"{ICON_AGENT} Available Agents",
+            columns,
+            transform_agent,
+            skip_picker=(
+                not interactive_enabled
+                or picker_attempted
+                or simple
+                or any(param is not None for param in (agent_type, framework, name, version))
+            ),
+            use_pager=False,
+        )
+
+    except Exception as e:
+        raise click.ClickException(str(e)) from e

glaip_sdk/cli/commands/agents/run.py

@@ -0,0 +1,264 @@
+"""Run agent command.
+
+Authors:
+    Raymond Christopher (raymond.christopher@gdplabs.id)
+"""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+import click
+
+from glaip_sdk.cli.context import get_ctx_value, output_flags
+from glaip_sdk.cli.display import handle_json_output
+from glaip_sdk.cli.core.context import get_client
+from glaip_sdk.cli.core.rendering import build_renderer
+from glaip_sdk.cli.transcript import maybe_launch_post_run_viewer, store_transcript_for_session
+from glaip_sdk.cli.rich_helpers import print_markup
+from glaip_sdk.config.constants import DEFAULT_AGENT_RUN_TIMEOUT
+from glaip_sdk.exceptions import AgentTimeoutError
+from glaip_sdk.utils.rendering.renderer.toggle import TranscriptToggleController
+
+from ._common import (
+    _emit_verbose_guidance,
+    _get_agent_model_name,
+    _handle_command_exception,
+    _resolve_agent,
+    _running_in_slash_mode,
+    _safe_agent_attribute,
+    agents_group,
+    console,
+)
+
+from glaip_sdk.branding import SUCCESS_STYLE
+
+
+def _validate_run_input(input_option: str | None, input_text: str | None) -> str:
+    """Validate and determine the final input text for agent run."""
+    final_input_text = input_option if input_option else input_text
+
+    if not final_input_text:
+        raise click.ClickException("Input text is required. Use either positional argument or --input option.")
+
+    return final_input_text
+
+
+def _parse_chat_history(chat_history: str | None) -> list[dict[str, Any]] | None:
+    """Parse chat history JSON if provided."""
+    if not chat_history:
+        return None
+
+    try:
+        return json.loads(chat_history)
+    except json.JSONDecodeError as err:
+        raise click.ClickException("Invalid JSON in chat history") from err
+
+
+def _setup_run_renderer(ctx: Any, save: str | None, verbose: bool) -> Any:
+    """Set up renderer and working console for agent run."""
+    tty_enabled = bool(get_ctx_value(ctx, "tty", True))
+    return build_renderer(
+        ctx,
+        save_path=save,
+        verbose=verbose,
+        _tty_enabled=tty_enabled,
+    )
+
+
+def _maybe_attach_transcript_toggle(ctx: Any, renderer: Any) -> None:
+    """Attach transcript toggle controller when interactive TTY is available."""
+    if renderer is None:
+        return
+
+    console_obj = getattr(renderer, "console", None)
+    if console_obj is None or not getattr(console_obj, "is_terminal", False):
+        return
+
+    tty_enabled = bool(get_ctx_value(ctx, "tty", True))
+    if not tty_enabled:
+        return
+
+    controller = TranscriptToggleController(enabled=True)
+    renderer.transcript_controller = controller
+
+
+def _prepare_run_kwargs(
+    agent: Any,
+    final_input_text: str,
+    files: list[str] | None,
+    parsed_chat_history: list[dict[str, Any]] | None,
+    renderer: Any,
+    tty_enabled: bool,
+) -> dict[str, Any]:
+    """Prepare kwargs for agent run."""
+    run_kwargs = {
+        "agent_id": agent.id,
+        "message": final_input_text,
+        "files": list(files),
+        "agent_name": agent.name,
+        "tty": tty_enabled,
+    }
+
+    if parsed_chat_history:
+        run_kwargs["chat_history"] = parsed_chat_history
+
+    if renderer is not None:
+        run_kwargs["renderer"] = renderer
+
+    return run_kwargs
+
+
+def _handle_run_output(ctx: Any, result: Any, renderer: Any) -> None:
+    """Handle output formatting for agent run results."""
+    printed_by_renderer = bool(renderer)
+    selected_view = get_ctx_value(ctx, "view", "rich")
+
+    if not printed_by_renderer:
+        if selected_view == "json":
+            handle_json_output(ctx, {"output": result})
+        elif selected_view == "md":
+            click.echo(f"# Assistant\n\n{result}")
+        elif selected_view == "plain":
+            click.echo(result)
+
+
+def _save_run_transcript(save: str | None, result: Any, working_console: Any) -> None:
+    """Save transcript to file if requested."""
+    if not save:
+        return
+
+    ext = (save.rsplit(".", 1)[-1] or "").lower()
+    if ext == "json":
+        save_data = {
+            "output": result or "",
+            "full_debug_output": getattr(working_console, "get_captured_output", lambda: "")(),
+            "timestamp": "captured during agent execution",
+        }
+        content = json.dumps(save_data, indent=2)
+    else:
+        full_output = getattr(working_console, "get_captured_output", lambda: "")()
+        if full_output:
+            content = f"# Agent Debug Log\n\n{full_output}\n\n---\n\n## Final Result\n\n{result or ''}\n"
+        else:
+            content = f"# Assistant\n\n{result or ''}\n"
+
+    with open(save, "w", encoding="utf-8") as f:
+        f.write(content)
+    print_markup(f"[{SUCCESS_STYLE}]Full debug output saved to: {save}[/]", console=console)
+
+
+@agents_group.command()
+@click.argument("agent_ref")
+@click.argument("input_text", required=False)
+@click.option("--select", type=int, help="Choose among ambiguous matches (1-based)")
+@click.option("--input", "input_option", help="Input text for the agent")
+@click.option("--chat-history", help="JSON string of chat history")
+@click.option(
+    "--timeout",
+    default=DEFAULT_AGENT_RUN_TIMEOUT,
+    type=int,
+    help="Agent execution timeout in seconds (default: 300s)",
+)
+@click.option(
+    "--save",
+    type=click.Path(dir_okay=False, writable=True),
+    help="Save transcript to file (md or json)",
+)
+@click.option(
+    "--file",
+    "files",
+    multiple=True,
+    type=click.Path(exists=True),
+    help="Attach file(s)",
+)
+@click.option(
+    "--verbose/--no-verbose",
+    default=False,
+    help="Show detailed SSE events during streaming",
+)
+@output_flags()
+@click.pass_context
+def run(
+    ctx: Any,
+    agent_ref: str,
+    select: int | None,
+    input_text: str | None,
+    input_option: str | None,
+    chat_history: str | None,
+    timeout: float | None,
+    save: str | None,
+    files: tuple[str, ...] | None,
+    verbose: bool,
+) -> None:
+    r"""Run an agent with input text.
+
+    Usage: aip agents run <agent_ref> <input_text> [OPTIONS]
+
+    \b
+    Examples:
+        aip agents run my-agent "Hello world"
+        aip agents run agent-123 "Process this data" --timeout 600
+        aip agents run my-agent --input "Hello world"  # Legacy style
+    """
+    final_input_text = _validate_run_input(input_option, input_text)
+
+    if verbose:
+        _emit_verbose_guidance(ctx)
+        return
+
+    try:
+        client = get_client(ctx)
+        agent = _resolve_agent(ctx, client, agent_ref, select, interface_preference="fuzzy")
+
+        parsed_chat_history = _parse_chat_history(chat_history)
+        renderer, working_console = _setup_run_renderer(ctx, save, verbose)
+        _maybe_attach_transcript_toggle(ctx, renderer)
+
+        try:
+            client.timeout = float(timeout)
+        except Exception:  # pragma: no cover  # Defensive - timeout is int per Click, so float() always succeeds
+            pass
+
+        run_kwargs = _prepare_run_kwargs(
+            agent,
+            final_input_text,
+            files,
+            parsed_chat_history,
+            renderer,
+            bool(get_ctx_value(ctx, "tty", True)),
+        )
+
+        result = client.agents.run_agent(**run_kwargs, timeout=timeout)
+
+        slash_mode = _running_in_slash_mode(ctx)
+        agent_id = str(_safe_agent_attribute(agent, "id") or "") or None
+        agent_name = _safe_agent_attribute(agent, "name")
+        model_hint = _get_agent_model_name(agent)
+
+        transcript_context = store_transcript_for_session(
+            ctx,
+            renderer,
+            final_result=result,
+            agent_id=agent_id,
+            agent_name=agent_name,
+            model=model_hint,
+            source="slash" if slash_mode else "cli",
+        )
+
+        _handle_run_output(ctx, result, renderer)
+        _save_run_transcript(save, result, working_console)
+        maybe_launch_post_run_viewer(
+            ctx,
+            transcript_context,
+            console=console,
+            slash_mode=slash_mode,
+        )
+
+    except AgentTimeoutError as e:
+        error_msg = str(e)
+        handle_json_output(ctx, error=Exception(error_msg))
+        raise click.ClickException(error_msg) from e
+    except Exception as e:
+        _handle_command_exception(ctx, e)

glaip_sdk/cli/commands/agents/sync_langflow.py

@@ -0,0 +1,72 @@
+"""Sync LangFlow agents command.
+
+Authors:
+    Raymond Christopher (raymond.christopher@gdplabs.id)
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import click
+
+from glaip_sdk.cli.context import get_ctx_value, output_flags
+from glaip_sdk.cli.display import handle_json_output, handle_rich_output
+from glaip_sdk.cli.core.context import get_client
+from glaip_sdk.cli.rich_helpers import markup_text
+
+from ._common import _handle_command_exception, agents_group
+
+from glaip_sdk.branding import SUCCESS_STYLE
+
+
+@agents_group.command()
+@click.option(
+    "--base-url",
+    help="Custom LangFlow server base URL (overrides LANGFLOW_BASE_URL env var)",
+)
+@click.option("--api-key", help="Custom LangFlow API key (overrides LANGFLOW_API_KEY env var)")
+@output_flags()
+@click.pass_context
+def sync_langflow(ctx: Any, base_url: str | None, api_key: str | None) -> None:
+    r"""Sync agents with LangFlow server flows.
+
+    This command fetches all flows from the configured LangFlow server and
+    creates/updates corresponding agents in the platform.
+
+    The LangFlow server configuration can be provided via:
+    - Command options (--base-url, --api-key)
+    - Environment variables (LANGFLOW_BASE_URL, LANGFLOW_API_KEY)
+
+    \b
+    Examples:
+        aip agents sync-langflow
+        aip agents sync-langflow --base-url https://my-langflow.com --api-key my-key
+    """
+    try:
+        client = get_client(ctx)
+
+        # Perform the sync
+        result = client.sync_langflow_agents(base_url=base_url, api_key=api_key)
+
+        # Handle output format
+        handle_json_output(ctx, result)
+
+        # Show success message for non-JSON output
+        if get_ctx_value(ctx, "view") != "json":
+            # Extract some useful info from the result
+            success_count = result.get("data", {}).get("created_count", 0) + result.get("data", {}).get(
+                "updated_count", 0
+            )
+            total_count = result.get("data", {}).get("total_processed", 0)
+
+            handle_rich_output(
+                ctx,
+                markup_text(
+                    f"[{SUCCESS_STYLE}]✅ Successfully synced {success_count} LangFlow agents "
+                    f"({total_count} total processed)[/]"
+                ),
+            )
+
+    except Exception as e:
+        _handle_command_exception(ctx, e)