glaip-sdk 0.0.4__py3-none-any.whl → 0.0.5__py3-none-any.whl

glaip_sdk/cli/commands/agents.py

@@ -6,20 +6,43 @@ Authors:
 
 import json
 import os
-from datetime import datetime
 from pathlib import Path
-from typing import Any
 
 import click
 from rich.console import Console
-from rich.panel import Panel
 from rich.text import Text
 
-from glaip_sdk.config.constants import DEFAULT_AGENT_RUN_TIMEOUT, DEFAULT_MODEL
-from glaip_sdk.exceptions import AgentTimeoutError
-from glaip_sdk.utils import is_uuid
-
-from ..utils import (
+from glaip_sdk.cli.agent_config import (
+    merge_agent_config_with_cli_args as merge_import_with_cli_args,
+)
+from glaip_sdk.cli.agent_config import (
+    resolve_agent_language_model_selection as resolve_language_model_selection,
+)
+from glaip_sdk.cli.agent_config import (
+    sanitize_agent_config_for_cli as sanitize_agent_config,
+)
+from glaip_sdk.cli.display import (
+    build_resource_result_data,
+    display_agent_run_suggestions,
+    display_confirmation_prompt,
+    display_creation_success,
+    display_deletion_success,
+    display_update_success,
+    handle_json_output,
+    handle_rich_output,
+    print_api_error,
+)
+from glaip_sdk.cli.io import (
+    export_resource_to_file_with_validation as export_resource_to_file,
+)
+from glaip_sdk.cli.io import (
+    fetch_raw_resource_details,
+)
+from glaip_sdk.cli.io import (
+    load_resource_from_file_with_validation as load_resource_from_file,
+)
+from glaip_sdk.cli.resolution import resolve_resource_reference
+from glaip_sdk.cli.utils import (
     _fuzzy_pick_for_resources,
     build_renderer,
     coerce_to_row,
@@ -27,44 +50,27 @@ from ..utils import (
     output_flags,
     output_list,
     output_result,
-    resolve_resource,
 )
+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, DEFAULT_MODEL
+from glaip_sdk.exceptions import AgentTimeoutError
+from glaip_sdk.utils import format_datetime, is_uuid
+from glaip_sdk.utils.agent_config import normalize_agent_config_for_import
+from glaip_sdk.utils.import_export import convert_export_to_import_format
+from glaip_sdk.utils.validation import coerce_timeout
 
 console = Console()
 
-
-def _display_run_suggestions(agent):
-    """Display helpful suggestions for running the agent."""
-    console.print()
-    console.print(
-        Panel(
-            f"[bold blue]💡 Next Steps:[/bold blue]\n\n"
-            f"🚀 Run this agent:\n"
-            f'   [green]aip agents run {agent.id} "Your message here"[/green]\n\n'
-            f"📋 Or use the agent name:\n"
-            f'   [green]aip agents run "{agent.name}" "Your message here"[/green]\n\n'
-            f"🔧 Available options:\n"
-            f"   [dim]--chat-history[/dim]  Include previous conversation\n"
-            f"   [dim]--file[/dim]          Attach files\n"
-            f"   [dim]--input[/dim]         Alternative input method\n"
-            f"   [dim]--timeout[/dim]       Set execution timeout\n"
-            f"   [dim]--save[/dim]          Save transcript to file\n"
-            f"   [dim]--verbose[/dim]       Show detailed execution\n\n"
-            f"💡 [dim]Input text can be positional OR use --input flag (both work!)[/dim]",
-            title="🤖 Ready to Run Agent",
-            border_style="blue",
-            padding=(0, 1),
-        )
-    )
-
-
-def _format_datetime(dt):
-    """Format datetime object to readable string."""
-    if isinstance(dt, datetime):
-        return dt.strftime("%Y-%m-%d %H:%M:%S UTC")
-    elif dt is None:
-        return "N/A"
-    return dt
+# Error message constants
+AGENT_NOT_FOUND_ERROR = "Agent not found"
 
 
 def _fetch_full_agent_details(client, agent):
@@ -79,113 +85,6 @@ def _fetch_full_agent_details(client, agent):
     return agent
 
 
-def _build_agent_result_data(agent):
-    """Build standardized result data for agent display."""
-    return {
-        "id": str(getattr(agent, "id", "N/A")),
-        "name": getattr(agent, "name", "N/A"),
-        "type": getattr(agent, "type", "N/A"),
-        "framework": getattr(agent, "framework", "N/A"),
-        "version": getattr(agent, "version", "N/A"),
-        "description": getattr(agent, "description", "N/A"),
-        "instruction": getattr(agent, "instruction", "") or "-",
-        "created_at": _format_datetime(getattr(agent, "created_at", "N/A")),
-        "updated_at": _format_datetime(getattr(agent, "updated_at", "N/A")),
-        "metadata": getattr(agent, "metadata", "N/A"),
-        "language_model_id": getattr(agent, "language_model_id", "N/A"),
-        "agent_config": getattr(agent, "agent_config", "N/A"),
-        "tool_configs": getattr(agent, "tool_configs", {}),
-        "tools": getattr(agent, "tools", []),
-        "agents": getattr(agent, "agents", []),
-        "mcps": getattr(agent, "mcps", []),
-        "a2a_profile": getattr(agent, "a2a_profile", "N/A"),
-    }
-
-
-def _get_agent_attributes(agent):
-    """Dynamically get all relevant agent attributes for export."""
-    # Exclude these attributes from export (methods, private attrs, computed properties)
-    exclude_attrs = {
-        "id",
-        "created_at",
-        "updated_at",  # System-managed fields
-        "_client",
-        "_raw_data",  # Internal fields
-    }
-
-    # Methods and callable attributes to exclude
-    exclude_callables = {
-        "model_dump",
-        "dict",
-        "json",  # Pydantic methods
-        "get",
-        "post",
-        "put",
-        "delete",  # HTTP methods
-        "save",
-        "refresh",
-        "update",  # ORM methods
-    }
-
-    export_data = {}
-
-    # Method 1: Try Pydantic model_dump() if available (best for structured data)
-    if hasattr(agent, "model_dump") and callable(agent.model_dump):
-        try:
-            # Get all model fields
-            all_data = agent.model_dump()
-            # Filter out excluded attributes
-            for key, value in all_data.items():
-                if key not in exclude_attrs and key not in exclude_callables:
-                    export_data[key] = value
-            return export_data
-        except Exception:
-            # Fall back to manual attribute detection
-            pass
-
-    # Method 2: Manual attribute inspection with filtering
-    # Get all non-private, non-method attributes
-    all_attrs = []
-    if hasattr(agent, "__dict__"):
-        all_attrs.extend(agent.__dict__.keys())
-    if hasattr(agent, "__annotations__"):
-        all_attrs.extend(agent.__annotations__.keys())
-
-    # Remove duplicates and filter
-    all_attrs = list(set(all_attrs))
-
-    for attr in all_attrs:
-        # Skip excluded attributes
-        if (
-            attr in exclude_attrs
-            or attr.startswith("_")  # Private attributes
-            or attr in exclude_callables
-        ):
-            continue
-
-        # Skip callable attributes (methods, functions)
-        attr_value = getattr(agent, attr, None)
-        if callable(attr_value):
-            continue
-
-        # Add the attribute to export data
-        export_data[attr] = attr_value
-
-    return export_data
-
-
-def _build_agent_export_data(agent):
-    """Build comprehensive export data for agent (always includes all fields)."""
-    # Get all available agent attributes dynamically
-    all_agent_data = _get_agent_attributes(agent)
-
-    # Always include all detected attributes for comprehensive export
-    # Add default timeout if not present
-    if "timeout" not in all_agent_data:
-        all_agent_data["timeout"] = DEFAULT_AGENT_RUN_TIMEOUT
-    return all_agent_data
-
-
 def _get_agent_model_name(agent):
     """Extract model name from agent configuration."""
     # Try different possible locations for model name
@@ -200,231 +99,8 @@ def _get_agent_model_name(agent):
     return DEFAULT_MODEL
 
 
-def _extract_tool_ids(agent):
-    """Extract tool IDs from agent tools list for import compatibility."""
-    tools = getattr(agent, "tools", [])
-    if not tools:
-        return []
-
-    ids = []
-    for tool in tools:
-        if isinstance(tool, dict):
-            tool_id = tool.get("id")
-            if tool_id:
-                ids.append(tool_id)
-            else:
-                # Fallback to name if ID not available
-                name = tool.get("name", "")
-                if name:
-                    ids.append(name)
-        elif hasattr(tool, "id"):
-            ids.append(tool.id)
-        elif hasattr(tool, "name"):
-            ids.append(tool.name)
-        else:
-            ids.append(str(tool))
-    return ids
-
-
-def _extract_agent_ids(agent):
-    """Extract agent IDs from agent agents list for import compatibility."""
-    agents = getattr(agent, "agents", [])
-    if not agents:
-        return []
-
-    ids = []
-    for sub_agent in agents:
-        if isinstance(sub_agent, dict):
-            agent_id = sub_agent.get("id")
-            if agent_id:
-                ids.append(agent_id)
-            else:
-                # Fallback to name if ID not available
-                name = sub_agent.get("name", "")
-                if name:
-                    ids.append(name)
-        elif hasattr(sub_agent, "id"):
-            ids.append(sub_agent.id)
-        elif hasattr(sub_agent, "name"):
-            ids.append(sub_agent.name)
-        else:
-            ids.append(str(sub_agent))
-    return ids
-
-
-def _export_agent_to_file(agent, file_path: Path, format: str = "json"):
-    """Export agent to file (JSON or YAML) with comprehensive data."""
-    export_data = _build_agent_export_data(agent)
-
-    if format.lower() == "yaml" or file_path.suffix.lower() in [".yaml", ".yml"]:
-        _write_yaml_to_file(file_path, export_data)
-    else:
-        _write_json_to_file(file_path, export_data)
-
-
-def _load_agent_from_file(file_path: Path) -> dict[str, Any]:
-    """Load agent data from JSON or YAML file."""
-    if file_path.suffix.lower() in [".yaml", ".yml"]:
-        return _read_yaml_from_file(file_path)
-    else:
-        return _read_json_from_file(file_path)
-
-
-def _read_yaml_from_file(file_path: Path) -> dict[str, Any]:
-    """Read YAML data from file."""
-    try:
-        import yaml
-    except ImportError:
-        raise click.ClickException(
-            "PyYAML is required for YAML import. Install with: pip install PyYAML"
-        )
-
-    if not file_path.exists():
-        raise FileNotFoundError(f"File not found: {file_path}")
-
-    with open(file_path, encoding="utf-8") as f:
-        data = yaml.safe_load(f)
-
-    # Handle instruction_lines array format for user-friendly YAML
-    if "instruction_lines" in data and isinstance(data["instruction_lines"], list):
-        data["instruction"] = "\n\n".join(data["instruction_lines"])
-        del data["instruction_lines"]
-
-    # Handle instruction as list from YAML export (convert back to string)
-    if "instruction" in data and isinstance(data["instruction"], list):
-        data["instruction"] = "\n\n".join(data["instruction"])
-
-    return data
-
-
-def _extract_ids_from_export(items: list) -> list[str]:
-    """Extract IDs from export format (list of dicts with id/name fields)."""
-    ids = []
-    for item in items:
-        if isinstance(item, dict):
-            item_id = item.get("id")
-            if item_id:
-                ids.append(item_id)
-        elif isinstance(item, str):
-            ids.append(item)
-    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)."""
-    import_data = data.copy()
-
-    # Convert tools from dicts to IDs
-    if "tools" in import_data and isinstance(import_data["tools"], list):
-        import_data["tools"] = _extract_ids_from_export(import_data["tools"])
-
-    # Convert agents from dicts to IDs
-    if "agents" in import_data and isinstance(import_data["agents"], list):
-        import_data["agents"] = _extract_ids_from_export(import_data["agents"])
-
-    return import_data
-
-
-def _write_json_to_file(file_path: Path, data: dict[str, Any], indent: int = 2) -> None:
-    """Write data to JSON file with consistent formatting."""
-    with open(file_path, "w", encoding="utf-8") as f:
-        json.dump(data, f, indent=indent)
-
-
-def _write_yaml_to_file(file_path: Path, data: dict[str, Any]) -> None:
-    """Write data to YAML file with user-friendly formatting."""
-    try:
-        import yaml
-    except ImportError:
-        raise click.ClickException(
-            "PyYAML is required for YAML export. Install with: pip install PyYAML"
-        )
-
-    # Custom YAML dumper for user-friendly instruction formatting
-    class LiteralString(str):
-        pass
-
-    def literal_string_representer(dumper, data):
-        # Use literal block scalar (|) for multiline strings to preserve formatting
-        if "\n" in data:
-            return dumper.represent_scalar("tag:yaml.org,2002:str", data, style="|")
-        return dumper.represent_scalar("tag:yaml.org,2002:str", data)
-
-    # Add custom representer to the YAML dumper
-    yaml.add_representer(LiteralString, literal_string_representer)
-
-    # Convert instruction to LiteralString for proper formatting
-    if "instruction" in data and data["instruction"]:
-        data["instruction"] = LiteralString(data["instruction"])
-
-    with open(file_path, "w", encoding="utf-8") as f:
-        yaml.dump(
-            data, f, default_flow_style=False, allow_unicode=True, sort_keys=False
-        )
-
-
-def _read_json_from_file(file_path: Path) -> dict[str, Any]:
-    """Read JSON data from file with validation."""
-    if not file_path.exists():
-        raise FileNotFoundError(f"File not found: {file_path}")
-
-    if file_path.suffix.lower() != ".json":
-        raise ValueError(
-            f"Unsupported file format: {file_path.suffix}. Only JSON files are supported."
-        )
-
-    with open(file_path, encoding="utf-8") as f:
-        return json.load(f)
-
-
-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
-    """
-    if array_fields is None:
-        array_fields = ["tools", "agents"]
-
-    merged = {}
-
-    for key, cli_value in cli_args.items():
-        if cli_value is not None and (
-            not isinstance(cli_value, list | tuple) or len(cli_value) > 0
-        ):
-            # 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
-                import_value = import_data[key]
-                if isinstance(import_value, list):
-                    merged[key] = list(cli_value) + import_value
-                else:
-                    merged[key] = cli_value
-            else:
-                merged[key] = cli_value
-        elif key in import_data:
-            # Use imported value if no CLI value
-            merged[key] = import_data[key]
-
-    # Add any import-only fields
-    for key, import_value in import_data.items():
-        if key not in merged:
-            merged[key] = import_value
-
-    return merged
-
-
 def _resolve_resources_by_name(
-    client, items: tuple[str, ...], resource_type: str, find_func, label: str
+    _client, items: tuple[str, ...], resource_type: str, find_func, label: str
 ) -> list[str]:
     """Resolve resource names/IDs to IDs, handling ambiguity.
 
@@ -455,52 +131,81 @@ def _resolve_resources_by_name(
     return out
 
 
-def _display_agent_creation_success(agent, model=None, default_model=DEFAULT_MODEL):
-    """Display success message for agent creation/update."""
-    lm = getattr(agent, "model", None)
-    if not lm:
-        cfg = getattr(agent, "agent_config", {}) or {}
-        lm = (
-            cfg.get("lm_name")
-            or cfg.get("model")
-            or model  # Use provided model if specified
-            or f"{default_model} (backend default)"
-        )
-
-    panel = Panel(
-        f"[green]✅ Agent '{agent.name}' created successfully![/green]\n\n"
-        f"ID: {agent.id}\n"
-        f"Model: {lm}\n"
-        f"Type: {getattr(agent, 'type', 'config')}\n"
-        f"Framework: {getattr(agent, 'framework', 'langchain')}\n"
-        f"Version: {getattr(agent, 'version', '1.0')}",
-        title="🤖 Agent Created",
-        border_style="green",
-        padding=(0, 1),
-    )
-    console.print(panel)
-
-
-def _display_agent_update_success(agent):
-    """Display success message for agent update."""
-    console.print(Text(f"[green]✅ Agent '{agent.name}' updated successfully[/green]"))
-
-
 def _display_agent_details(ctx, client, agent):
-    """Display full agent details in a standardized format."""
-    # Fetch full details to ensure all fields are populated
-    full_agent = _fetch_full_agent_details(client, agent)
-
-    # Build result data
-    result_data = _build_agent_result_data(full_agent)
-
-    # Display using output_result
-    output_result(
-        ctx,
-        result_data,
-        title="Agent Details",
-        panel_title=f"🤖 {full_agent.name}",
-    )
+    """Display full agent details using raw API data to preserve ALL fields."""
+    if agent is None:
+        handle_rich_output(ctx, Text("[red]❌ No agent provided[/red]"))
+        return
+
+    # Try to fetch raw API data first to preserve ALL fields
+    raw_agent_data = fetch_raw_resource_details(client, agent, "agents")
+
+    if raw_agent_data:
+        # Use raw API data - this preserves ALL fields including account_id
+        # Format dates for better display (minimal postprocessing)
+        formatted_data = raw_agent_data.copy()
+        if "created_at" in formatted_data:
+            formatted_data["created_at"] = format_datetime(formatted_data["created_at"])
+        if "updated_at" in formatted_data:
+            formatted_data["updated_at"] = format_datetime(formatted_data["updated_at"])
+
+        # Display using output_result with raw data
+        output_result(
+            ctx,
+            formatted_data,
+            title="Agent Details",
+            panel_title=f"🤖 {raw_agent_data.get('name', 'Unknown')}",
+        )
+    else:
+        # Fall back to original method if raw fetch fails
+        handle_rich_output(
+            ctx, Text("[yellow]Falling back to Pydantic model data[/yellow]")
+        )
+        full_agent = _fetch_full_agent_details(client, agent)
+
+        # Build result data using standardized helper
+        fields = [
+            "id",
+            "name",
+            "type",
+            "framework",
+            "version",
+            "description",
+            "instruction",
+            "created_at",
+            "updated_at",
+            "metadata",
+            "language_model_id",
+            "agent_config",
+            "tool_configs",
+            "tools",
+            "agents",
+            "mcps",
+            "a2a_profile",
+        ]
+        result_data = build_resource_result_data(full_agent, fields)
+        if not result_data.get("instruction"):
+            result_data["instruction"] = "-"  # pragma: no cover - cosmetic fallback
+
+        # Format dates for better display
+        if "created_at" in result_data and result_data["created_at"] not in [
+            "N/A",
+            None,
+        ]:
+            result_data["created_at"] = format_datetime(result_data["created_at"])
+        if "updated_at" in result_data and result_data["updated_at"] not in [
+            "N/A",
+            None,
+        ]:
+            result_data["updated_at"] = format_datetime(result_data["updated_at"])
+
+        # Display using output_result
+        output_result(
+            ctx,
+            result_data,
+            title="Agent Details",
+            panel_title=f"🤖 {full_agent.name}",
+        )
 
 
 @click.group(name="agents", no_args_is_help=True)
@@ -515,12 +220,14 @@ def _resolve_agent(ctx, client, ref, select=None, interface_preference="fuzzy"):
     Args:
         interface_preference: "fuzzy" for fuzzy picker, "questionary" for up/down list
     """
-    return resolve_resource(
+    return resolve_resource_reference(
         ctx,
+        client,
         ref,
-        get_by_id=client.agents.get_agent_by_id,
-        find_by_name=client.agents.find_agents,
-        label="Agent",
+        "agent",
+        client.agents.get_agent_by_id,
+        client.agents.find_agents,
+        "Agent",
         select=select,
         interface_preference=interface_preference,
     )
@@ -530,13 +237,32 @@ def _resolve_agent(ctx, client, ref, select=None, interface_preference="fuzzy"):
 @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, simple):
-    """List all agents."""
+def list_agents(ctx, simple, agent_type, framework, name, version, sync_langflow):
+    """List agents with optional filtering."""
     try:
         client = get_client(ctx)
-        agents = client.agents.list_agents()
+        agents = client.agents.list_agents(
+            agent_type=agent_type,
+            framework=framework,
+            name=name,
+            version=version,
+            sync_langflow_agents=sync_langflow,
+        )
 
         # Define table columns: (data_key, header, style, width)
         columns = [
@@ -560,6 +286,8 @@ def list_agents(ctx, simple):
             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)
@@ -596,7 +324,7 @@ def get(ctx, agent_ref, select, export):
         )
 
         # Handle export option
-        if export:
+        if export:  # pragma: no cover - requires filesystem verification
             export_path = Path(export)
             # Auto-detect format from file extension
             if export_path.suffix.lower() in [".yaml", ".yml"]:
@@ -607,32 +335,131 @@ def get(ctx, agent_ref, select, export):
             # Always export comprehensive data - re-fetch agent with full details
             try:
                 agent = client.agents.get_agent_by_id(agent.id)
-            except Exception as e:
-                console.print(
-                    Text(f"[yellow]⚠️  Could not fetch full agent details: {e}[/yellow]")
+            except Exception as e:  # pragma: no cover - best-effort fallback messaging
+                handle_rich_output(
+                    ctx,
+                    Text(
+                        f"[yellow]⚠️  Could not fetch full agent details: {e}[/yellow]"
+                    ),
                 )
-                console.print(
-                    Text("[yellow]⚠️  Proceeding with available data[/yellow]")
+                handle_rich_output(
+                    ctx, Text("[yellow]⚠️  Proceeding with available data[/yellow]")
                 )
 
-            _export_agent_to_file(agent, export_path, detected_format)
-            console.print(
+            export_resource_to_file(agent, export_path, detected_format)
+            handle_rich_output(
+                ctx,
                 Text(
                     f"[green]✅ Complete agent configuration exported to: {export_path} (format: {detected_format})[/green]"
-                )
+                ),
             )
 
         # Display full agent details using the standardized helper
         _display_agent_details(ctx, client, agent)
 
-        # Show run suggestions (only in rich mode, not JSON)
-        if ctx.obj.get("view") != "json":
-            _display_run_suggestions(agent)
+        # Show run suggestions via centralized display helper
+        handle_rich_output(ctx, display_agent_run_suggestions(agent))
 
     except Exception as e:
         raise click.ClickException(str(e))
 
 
+def _validate_run_input(input_option, input_text):
+    """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):
+    """Parse chat history JSON if provided."""
+    if not chat_history:
+        return None
+
+    try:
+        return json.loads(chat_history)
+    except json.JSONDecodeError:
+        raise click.ClickException("Invalid JSON in chat history")
+
+
+def _setup_run_renderer(ctx, save, verbose):
+    """Set up renderer and working console for agent run."""
+    tty_enabled = bool((ctx.obj or {}).get("tty", True))
+    return build_renderer(
+        ctx,
+        save_path=save,
+        verbose=verbose,
+        _tty_enabled=tty_enabled,
+    )
+
+
+def _prepare_run_kwargs(
+    agent, final_input_text, files, parsed_chat_history, renderer, tty_enabled
+):
+    """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, result, renderer):
+    """Handle output formatting for agent run results."""
+    printed_by_renderer = bool(renderer)
+    selected_view = (ctx.obj or {}).get("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, result, working_console):
+    """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)
+    console.print(Text(f"[green]Full debug output saved to: {save}[/green]"))
+
+
 @agents_group.command()
 @click.argument("agent_ref")
 @click.argument("input_text", required=False)
@@ -685,126 +512,42 @@ def run(
         aip agents run agent-123 "Process this data" --timeout 600
         aip agents run my-agent --input "Hello world"  # Legacy style
     """
-    # Handle input precedence: --input option overrides positional argument
-    final_input_text = input_option if input_option else input_text
-
-    # Validate that we have input text from either positional argument or --input option
-    if not final_input_text:
-        raise click.ClickException(
-            "Input text is required. Use either positional argument or --input option."
-        )
+    final_input_text = _validate_run_input(input_option, input_text)
 
     try:
         client = get_client(ctx)
-
-        # Resolve agent by ID or name (align with other commands) - use fuzzy interface
         agent = _resolve_agent(
             ctx, client, agent_ref, select, interface_preference="fuzzy"
         )
 
-        # Parse chat history if provided
-        parsed_chat_history = None
-        if chat_history:
-            try:
-                parsed_chat_history = json.loads(chat_history)
-            except json.JSONDecodeError:
-                raise click.ClickException("Invalid JSON in chat history")
-
-        # Create custom renderer with CLI flags
-        tty_enabled = bool((ctx.obj or {}).get("tty", True))
-
-        # Build renderer and capturing console
-        renderer, working_console = build_renderer(
-            ctx,
-            save_path=save,
-            verbose=verbose,
-            tty_enabled=tty_enabled,
-        )
+        parsed_chat_history = _parse_chat_history(chat_history)
+        renderer, working_console = _setup_run_renderer(ctx, save, verbose)
 
-        # Set HTTP timeout to match agent timeout exactly
-        # This ensures the agent timeout controls the HTTP timeout
         try:
             client.timeout = float(timeout)
         except Exception:
             pass
 
-        # Ensure timeout is applied to the root client and subclients share its session
-        run_kwargs = {
-            "agent_id": agent.id,
-            "message": final_input_text,
-            "files": list(files),
-            "agent_name": agent.name,  # Pass agent name for better display
-            "tty": tty_enabled,
-        }
-
-        # Add optional parameters
-        if parsed_chat_history:
-            run_kwargs["chat_history"] = parsed_chat_history
-
-        # Pass custom renderer if available
-        if renderer is not None:
-            run_kwargs["renderer"] = renderer
+        run_kwargs = _prepare_run_kwargs(
+            agent,
+            final_input_text,
+            files,
+            parsed_chat_history,
+            renderer,
+            bool((ctx.obj or {}).get("tty", True)),
+        )
 
-        # Pass timeout to client (verbose mode is handled by the renderer)
         result = client.agents.run_agent(**run_kwargs, timeout=timeout)
 
-        # Check if renderer already printed output (for streaming renderers)
-        # Note: Auto-paging is handled by the renderer when view=="rich"
-        printed_by_renderer = bool(renderer)
-
-        # Resolve selected view from context (output_flags() stores it here)
-        selected_view = (ctx.obj or {}).get("view", "rich")
-
-        # Handle output format for fallback
-        # Only print here if nothing was printed by the renderer
-        if not printed_by_renderer:
-            if selected_view == "json":
-                click.echo(json.dumps({"output": result}, indent=2))
-            elif selected_view == "md":
-                click.echo(f"# Assistant\n\n{result}")
-            elif selected_view == "plain":
-                click.echo(result)
-
-        # Save transcript if requested
-        if save:
-            ext = (save.rsplit(".", 1)[-1] or "").lower()
-            if ext == "json":
-                # Save both the result and captured output
-                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:
-                # For markdown/text files, save the full captured output if available
-                # Get the full captured output including all tool panels and debug info (if available)
-                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:
-                    # Fallback to simple format
-                    content = f"# Assistant\n\n{result or ''}\n"
-
-            with open(save, "w", encoding="utf-8") as f:
-                f.write(content)
-            console.print(Text(f"[green]Full debug output saved to: {save}[/green]"))
+        _handle_run_output(ctx, result, renderer)
+        _save_run_transcript(save, result, working_console)
 
     except AgentTimeoutError as e:
-        # Handle agent timeout errors with specific messages
         error_msg = str(e)
-        if ctx.obj.get("view") == "json":
-            click.echo(json.dumps({"error": error_msg}, indent=2))
-        # Don't print the error message here - Click.ClickException will handle it
+        handle_json_output(ctx, error=Exception(error_msg))
         raise click.ClickException(error_msg)
     except Exception as e:
-        if ctx.obj.get("view") == "json":
-            click.echo(json.dumps({"error": str(e)}, indent=2))
-        # Don't print the error message here - Click.ClickException will handle it
+        handle_json_output(ctx, error=e)
         raise click.ClickException(str(e))
 
 
@@ -817,6 +560,7 @@ def run(
 )
 @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,
@@ -838,6 +582,7 @@ def create(
     model,
     tools,
     agents,
+    mcps,
     timeout,
     import_file,
 ):
@@ -850,12 +595,20 @@ def create(
     try:
         client = get_client(ctx)
 
+        # Initialize merged_data for cases without import_file
+        merged_data = {}
+
         # Handle import from file
-        if import_file:
-            import_data = _load_agent_from_file(Path(import_file))
+        if (
+            import_file
+        ):  # pragma: no cover - exercised in higher-level integration tests
+            import_data = load_resource_from_file(Path(import_file), "agent")
 
             # Convert export format to import-compatible format
-            import_data = _convert_export_to_import_format(import_data)
+            import_data = convert_export_to_import_format(import_data)
+
+            # Auto-normalize agent config (extract LM settings from agent_config)
+            import_data = normalize_agent_config_for_import(import_data, model)
 
             # Merge CLI args with imported data
             cli_args = {
@@ -864,20 +617,35 @@ def create(
                 "model": model,
                 "tools": tools or (),
                 "agents": agents or (),
+                "mcps": mcps or (),
                 "timeout": timeout if timeout != DEFAULT_AGENT_RUN_TIMEOUT else None,
             }
 
-            merged_data = _merge_import_with_cli_args(import_data, cli_args)
-
-            # Extract merged values
-            name = merged_data.get("name")
-            instruction = merged_data.get("instruction")
-            model = merged_data.get("model")
-            tools = tuple(merged_data.get("tools", ()))
-            agents = tuple(merged_data.get("agents", ()))
-            timeout = merged_data.get("timeout", DEFAULT_AGENT_RUN_TIMEOUT)
+            merged_data = merge_import_with_cli_args(import_data, cli_args)
+        else:
+            # No import file - use CLI args directly
+            merged_data = {
+                "name": name,
+                "instruction": instruction,
+                "model": model,
+                "tools": tools or (),
+                "agents": agents or (),
+                "mcps": mcps or (),
+                "timeout": timeout if timeout != DEFAULT_AGENT_RUN_TIMEOUT else None,
+            }
 
-        # Validate required fields
+        # Extract merged values
+        name = merged_data.get("name")
+        instruction = merged_data.get("instruction")
+        model = merged_data.get("model")
+        tools = tuple(merged_data.get("tools", ()))
+        agents = tuple(merged_data.get("agents", ()))
+        mcps = tuple(merged_data.get("mcps", ()))
+        timeout = merged_data.get("timeout", DEFAULT_AGENT_RUN_TIMEOUT)
+        # Coerce timeout to proper integer type
+        timeout = coerce_timeout(timeout)
+
+        # Validate required fields using centralized validators
         if not name:
             raise click.ClickException("Agent name is required (--name or --import)")
         if not instruction:
@@ -885,6 +653,12 @@ def create(
                 "Agent instruction is required (--instruction or --import)"
             )
 
+        # Apply validation
+        name = validate_agent_name(name)
+        instruction = validate_agent_instruction(instruction)
+        if timeout is not None:
+            timeout = validate_timeout(timeout)
+
         # Resolve tool and agent references: accept names or IDs
         resolved_tools = _resolve_resources_by_name(
             client, tools, "tool", client.find_tools, "Tool"
@@ -892,6 +666,9 @@ def create(
         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"
+        )
 
         # Create agent with comprehensive attribute support
         create_kwargs = {
@@ -899,21 +676,28 @@ def create(
             "instruction": instruction,
             "tools": resolved_tools or None,
             "agents": resolved_agents or None,
+            "mcps": resolved_mcps or None,
             "timeout": timeout,
         }
 
-        # Add model if specified (prioritize CLI model over imported model)
-        if model:
-            create_kwargs["model"] = model
-        elif (
-            import_file
-            and "agent_config" in merged_data
-            and merged_data["agent_config"]
-        ):
-            # Use lm_name from agent_config for cloning
-            agent_config = merged_data["agent_config"]
-            if isinstance(agent_config, dict) and "lm_name" in agent_config:
-                create_kwargs["model"] = agent_config["lm_name"]
+        # Handle language model selection using helper function
+        lm_selection_dict, should_strip_lm_identity = resolve_language_model_selection(
+            merged_data, model
+        )
+        create_kwargs.update(lm_selection_dict)
+
+        # If importing from file, include agent_config (pass-through minus credentials)
+        if import_file:
+            agent_config_raw = (
+                merged_data.get("agent_config")
+                if isinstance(merged_data, dict)
+                else None
+            )
+            if isinstance(agent_config_raw, dict):
+                # If language_model_id is used, strip LM identity keys from agent_config to avoid conflicts
+                create_kwargs["agent_config"] = sanitize_agent_config(
+                    agent_config_raw, strip_lm_identity=should_strip_lm_identity
+                )
 
         # If importing from file, include all other detected attributes
         if import_file:
@@ -922,15 +706,15 @@ def create(
                 "name",
                 "instruction",
                 "model",
+                "language_model_id",
                 "tools",
                 "agents",
                 "timeout",
+                "agent_config",  # handled explicitly above
                 # System-only fields that shouldn't be passed to create_agent
                 "id",
                 "created_at",
                 "updated_at",
-                "agent_config",
-                "language_model_id",
                 "type",
                 "framework",
                 "version",
@@ -944,24 +728,139 @@ def create(
 
         agent = client.agents.create_agent(**create_kwargs)
 
-        if ctx.obj.get("view") == "json":
-            click.echo(json.dumps(agent.model_dump(), indent=2))
-        else:
-            # Rich output
-            _display_agent_creation_success(agent, model)
+        handle_json_output(ctx, agent.model_dump())
 
-            # Show run suggestions (only in rich mode, not JSON)
-            if ctx.obj.get("view") != "json":
-                _display_run_suggestions(agent)
+        lm_display = getattr(agent, "model", None)
+        if not lm_display:
+            cfg = getattr(agent, "agent_config", {}) or {}
+            lm_display = (
+                cfg.get("lm_name")
+                or cfg.get("model")
+                or model
+                or f"{DEFAULT_MODEL} (backend default)"
+            )
 
-    except Exception as e:
+        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))
+
+    except (
+        click.ClickException
+    ):  # pragma: no cover - error formatting verified elsewhere
+        # Handle JSON output for ClickExceptions if view is JSON
         if ctx.obj.get("view") == "json":
-            click.echo(json.dumps({"error": str(e)}, indent=2))
-        else:
-            console.print(Text(f"[red]Error creating agent: {e}[/red]"))
+            handle_json_output(ctx, error=Exception(AGENT_NOT_FOUND_ERROR))
+        # Re-raise ClickExceptions without additional processing
+        raise
+    except Exception as e:  # pragma: no cover - defensive logging path
+        handle_json_output(ctx, error=e)
+        if ctx.obj.get("view") != "json":
+            print_api_error(e)
         raise click.ClickException(str(e))
 
 
+def _get_agent_for_update(client, agent_id):
+    """Retrieve agent by ID for update operation."""
+    try:
+        return client.agents.get_agent_by_id(agent_id)
+    except Exception as e:
+        raise click.ClickException(f"Agent with ID '{agent_id}' not found: {e}")
+
+
+def _handle_update_import_file(import_file, name, instruction, tools, agents, timeout):
+    """Handle import file processing for agent update."""
+    if not import_file:
+        return None, name, instruction, tools, agents, timeout
+
+    import_data = load_resource_from_file(Path(import_file), "agent")
+    import_data = convert_export_to_import_format(import_data)
+    import_data = normalize_agent_config_for_import(import_data, None)
+
+    cli_args = {
+        "name": name,
+        "instruction": instruction,
+        "tools": tools or (),
+        "agents": agents or (),
+        "timeout": timeout,
+    }
+
+    merged_data = merge_import_with_cli_args(import_data, cli_args)
+
+    return (
+        merged_data,
+        merged_data.get("name"),
+        merged_data.get("instruction"),
+        tuple(merged_data.get("tools", ())),
+        tuple(merged_data.get("agents", ())),
+        coerce_timeout(merged_data.get("timeout")),
+    )
+
+
+def _build_update_data(name, instruction, tools, agents, timeout):
+    """Build the update data dictionary from provided parameters."""
+    update_data = {}
+    if name is not None:
+        update_data["name"] = name
+    if instruction is not None:
+        update_data["instruction"] = instruction
+    if tools:
+        update_data["tools"] = list(tools)
+    if agents:
+        update_data["agents"] = list(agents)
+    if timeout is not None:
+        update_data["timeout"] = timeout
+    return update_data
+
+
+def _handle_update_import_config(import_file, merged_data, update_data):
+    """Handle agent config and additional attributes for import-based updates."""
+    if not import_file:
+        return
+
+    lm_selection, should_strip_lm_identity = resolve_language_model_selection(
+        merged_data, None
+    )
+    update_data.update(lm_selection)
+
+    raw_cfg = merged_data.get("agent_config") if isinstance(merged_data, dict) else None
+    if isinstance(raw_cfg, dict):
+        update_data["agent_config"] = sanitize_agent_config(
+            raw_cfg, strip_lm_identity=should_strip_lm_identity
+        )
+
+    excluded_fields = {
+        "name",
+        "instruction",
+        "tools",
+        "agents",
+        "timeout",
+        "agent_config",
+        "language_model_id",
+        "id",
+        "created_at",
+        "updated_at",
+        "type",
+        "framework",
+        "version",
+        "tool_configs",
+        "mcps",
+        "a2a_profile",
+    }
+    for key, value in merged_data.items():
+        if key not in excluded_fields and value is not None:
+            update_data[key] = value
+
+
 @agents_group.command()
 @click.argument("agent_id")
 @click.option("--name", help="New agent name")
@@ -986,96 +885,39 @@ def update(ctx, agent_id, name, instruction, tools, agents, timeout, import_file
     """
     try:
         client = get_client(ctx)
+        agent = _get_agent_for_update(client, agent_id)
 
-        # 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}")
+        # Handle import file processing
+        merged_data, name, instruction, tools, agents, timeout = (
+            _handle_update_import_file(
+                import_file, name, instruction, tools, agents, timeout
+            )
+        )
 
-        # Handle import from file
-        if import_file:
-            import_data = _load_agent_from_file(Path(import_file))
+        update_data = _build_update_data(name, instruction, tools, agents, timeout)
 
-            # Convert export format to import-compatible format
-            import_data = _convert_export_to_import_format(import_data)
-
-            # Merge CLI args with imported data
-            cli_args = {
-                "name": name,
-                "instruction": instruction,
-                "tools": tools or (),
-                "agents": agents or (),
-                "timeout": timeout,
-            }
-
-            merged_data = _merge_import_with_cli_args(import_data, cli_args)
-
-            # Extract merged values
-            name = merged_data.get("name")
-            instruction = merged_data.get("instruction")
-            tools = tuple(merged_data.get("tools", ()))
-            agents = tuple(merged_data.get("agents", ()))
-            timeout = merged_data.get("timeout")
-
-        # Build update data with comprehensive attribute support
-        update_data = {}
-        if name is not None:
-            update_data["name"] = name
-        if instruction is not None:
-            update_data["instruction"] = instruction
-        if tools:
-            update_data["tools"] = list(tools)
-        if agents:
-            update_data["agents"] = list(agents)
-        if timeout is not None:
-            update_data["timeout"] = timeout
-
-        # If importing from file, include all other detected attributes
-        if import_file:
-            # Add all other attributes from import data (excluding already handled ones and system-only fields)
-            excluded_fields = {
-                "name",
-                "instruction",
-                "tools",
-                "agents",
-                "timeout",
-                # System-only fields that shouldn't be passed to update_agent
-                "id",
-                "created_at",
-                "updated_at",
-                "agent_config",
-                "type",
-                "framework",
-                "version",
-                "tool_configs",
-                "mcps",
-                "a2a_profile",
-            }
-            for key, value in merged_data.items():
-                if key not in excluded_fields and value is not None:
-                    update_data[key] = value
+        if merged_data:
+            _handle_update_import_config(import_file, merged_data, update_data)
 
         if not update_data:
             raise click.ClickException("No update fields specified")
 
-        # Update agent
         updated_agent = client.agents.update_agent(agent.id, **update_data)
 
-        if ctx.obj.get("view") == "json":
-            click.echo(json.dumps(updated_agent.model_dump(), indent=2))
-        else:
-            _display_agent_update_success(updated_agent)
+        handle_json_output(ctx, updated_agent.model_dump())
+        handle_rich_output(ctx, display_update_success("Agent", updated_agent.name))
+        handle_rich_output(ctx, display_agent_run_suggestions(updated_agent))
 
-            # Show run suggestions (only in rich mode, not JSON)
-            if ctx.obj.get("view") != "json":
-                _display_run_suggestions(updated_agent)
-
-    except Exception as e:
+    except click.ClickException:
+        # Handle JSON output for ClickExceptions if view is JSON
         if ctx.obj.get("view") == "json":
-            click.echo(json.dumps({"error": str(e)}, indent=2))
-        else:
-            console.print(Text(f"[red]Error updating agent: {e}[/red]"))
+            handle_json_output(ctx, error=Exception(AGENT_NOT_FOUND_ERROR))
+        # Re-raise ClickExceptions without additional processing
+        raise
+    except Exception as e:
+        handle_json_output(ctx, error=e)
+        if ctx.obj.get("view") != "json":
+            print_api_error(e)
         raise click.ClickException(str(e))
 
 
@@ -1095,31 +937,86 @@ def delete(ctx, agent_id, yes):
         except Exception as e:
             raise click.ClickException(f"Agent with ID '{agent_id}' not found: {e}")
 
-        # Confirm deletion
-        if not yes and not click.confirm(
-            f"Are you sure you want to delete agent '{agent.name}'?"
-        ):
-            if ctx.obj.get("view") != "json":
-                console.print(Text("Deletion cancelled."))
+        # Confirm deletion when not forced
+        if not yes and 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:
+        # Handle JSON output for ClickExceptions if view is JSON
         if ctx.obj.get("view") == "json":
-            click.echo(
-                json.dumps(
-                    {"success": True, "message": f"Agent '{agent.name}' deleted"},
-                    indent=2,
-                )
-            )
-        else:
-            console.print(
-                Text(f"[green]✅ Agent '{agent.name}' deleted successfully[/green]")
+            handle_json_output(ctx, error=Exception(AGENT_NOT_FOUND_ERROR))
+        # Re-raise ClickExceptions without additional processing
+        raise
+    except Exception as e:
+        handle_json_output(ctx, error=e)
+        if ctx.obj.get("view") != "json":
+            print_api_error(e)
+        raise click.ClickException(str(e))
+
+
+@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, base_url, api_key):  # pragma: no cover - integration-only path
+    """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)
+
+    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 ctx.obj.get("view") != "json":
+            from rich.text import Text
+
+            # 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,
+                Text(
+                    f"[green]✅ Successfully synced {success_count} LangFlow agents ({total_count} total processed)[/green]"
+                ),
             )
 
     except Exception as e:
-        if ctx.obj.get("view") == "json":
-            click.echo(json.dumps({"error": str(e)}, indent=2))
-        else:
-            console.print(Text(f"[red]Error deleting agent: {e}[/red]"))
+        handle_json_output(ctx, error=e)
+        if ctx.obj.get("view") != "json":
+            print_api_error(e)
         raise click.ClickException(str(e))