glaip-sdk 0.1.2__py3-none-any.whl → 0.7.17__py3-none-any.whl

glaip_sdk/cli/commands/agents/create.py

@@ -0,0 +1,155 @@
+"""Create 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.core.context import get_client
+from glaip_sdk.cli.display import (
+    display_agent_run_suggestions,
+    display_creation_success,
+    handle_json_output,
+    handle_rich_output,
+)
+from glaip_sdk.cli.validators import (
+    validate_agent_instruction_cli as validate_agent_instruction,
+)
+from glaip_sdk.cli.validators import validate_agent_name_cli as validate_agent_name
+from glaip_sdk.cli.validators import validate_timeout_cli as validate_timeout
+from glaip_sdk.config.constants import DEFAULT_AGENT_RUN_TIMEOUT
+from glaip_sdk.utils.validation import coerce_timeout
+
+from ._common import (
+    _get_language_model_display_name,
+    _handle_command_exception,
+    _prepare_agent_output,
+    _resolve_resources_by_name,
+    _split_comma_separated_refs,
+    agents_group,
+)
+
+
+def _handle_successful_creation(ctx: Any, agent: Any, model: str | None) -> None:
+    """Handle successful agent creation output."""
+    handle_json_output(ctx, _prepare_agent_output(agent))
+
+    lm_display = _get_language_model_display_name(agent, model)
+
+    handle_rich_output(
+        ctx,
+        display_creation_success(
+            "Agent",
+            agent.name,
+            agent.id,
+            Model=lm_display,
+            Type=getattr(agent, "type", "config"),
+            Framework=getattr(agent, "framework", "langchain"),
+            Version=getattr(agent, "version", "1.0"),
+        ),
+    )
+    handle_rich_output(ctx, display_agent_run_suggestions(agent))
+
+
+def _handle_creation_exception(ctx: Any, e: Exception) -> None:
+    """Handle exceptions during agent creation."""
+    _handle_command_exception(ctx, e)
+
+
+@agents_group.command()
+@click.option("--name", help="Agent name")
+@click.option("--instruction", help="Agent instruction (prompt)")
+@click.option(
+    "--model",
+    help=(
+        "Language model in 'provider/model' format "
+        "(e.g., openai/gpt-4o-mini, bedrock/us.anthropic.claude-sonnet-4-20250514-v1:0). "
+        "Use 'aip models list' to see available models."
+    ),
+)
+@click.option("--tools", multiple=True, help="Tool names or IDs to attach")
+@click.option("--agents", multiple=True, help="Sub-agent names or IDs to attach")
+@click.option("--mcps", multiple=True, help="MCP names or IDs to attach")
+@click.option(
+    "--timeout",
+    default=DEFAULT_AGENT_RUN_TIMEOUT,
+    type=int,
+    help="Agent execution timeout in seconds (default: 300s)",
+)
+@click.option(
+    "--import",
+    "import_file",
+    type=click.Path(exists=True, dir_okay=False),
+    help="Import agent configuration from JSON file",
+)
+@output_flags()
+@click.pass_context
+def create(
+    ctx: Any,
+    name: str,
+    instruction: str,
+    model: str | None,
+    tools: tuple[str, ...] | None,
+    agents: tuple[str, ...] | None,
+    mcps: tuple[str, ...] | None,
+    timeout: float | None,
+    import_file: str | None,
+) -> None:
+    r"""Create a new agent.
+
+    \b
+    Examples:
+        aip agents create --name "My Agent" --instruction "You are a helpful assistant"
+        aip agents create --import agent.json
+    """
+    try:
+        client = get_client(ctx)
+
+        if import_file is None:
+            if not name:
+                raise click.ClickException("Agent name is required (--name or --import)")
+            if not instruction:
+                raise click.ClickException("Agent instruction is required (--instruction or --import)")
+
+        if name is not None:
+            name = validate_agent_name(name)
+        if instruction is not None:
+            instruction = validate_agent_instruction(instruction)
+
+        timeout_value = coerce_timeout(timeout)
+        if timeout_value is not None:
+            timeout_value = validate_timeout(timeout_value)
+        if import_file is None and timeout_value == DEFAULT_AGENT_RUN_TIMEOUT:
+            timeout_value = None
+
+        tools = _split_comma_separated_refs(tools)
+        agents = _split_comma_separated_refs(agents)
+        mcps = _split_comma_separated_refs(mcps)
+
+        # Resolve resources
+        resolved_tools = _resolve_resources_by_name(client, tools, "tool", client.find_tools, "Tool")
+        resolved_agents = _resolve_resources_by_name(client, agents, "agent", client.find_agents, "Agent")
+        resolved_mcps = _resolve_resources_by_name(client, mcps, "mcp", client.find_mcps, "MCP")
+
+        agent = client.agents.create_agent(
+            file=import_file,
+            name=name,
+            instruction=instruction,
+            model=model,
+            tools=resolved_tools or None,
+            agents=resolved_agents or None,
+            mcps=resolved_mcps or None,
+            timeout=timeout_value,
+        )
+
+        # Handle successful creation
+        _handle_successful_creation(ctx, agent, model)
+
+    except Exception as e:
+        _handle_creation_exception(ctx, e)

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)