glaip-sdk 0.0.2__py3-none-any.whl → 0.0.3__py3-none-any.whl

glaip_sdk/__init__.py

@@ -4,9 +4,9 @@ Authors:
     Raymond Christopher (raymond.christopher@gdplabs.id)
 """
 
+from ._version import __version__
 from .client import Client
 from .exceptions import AIPError
 from .models import MCP, Agent, Tool
 
-__version__ = "0.1.1"
-__all__ = ["Client", "Agent", "Tool", "MCP", "AIPError"]
+__all__ = ["Client", "Agent", "Tool", "MCP", "AIPError", "__version__"]

glaip_sdk/_version.py

@@ -0,0 +1,51 @@
+"""Central version definition for glaip_sdk.
+
+Resolves from installed package metadata to avoid hardcoding.
+Falls back to a dev marker when running from source without installation.
+"""
+
+from __future__ import annotations
+
+try:
+    from importlib.metadata import PackageNotFoundError, version  # Python 3.8+
+except Exception:  # pragma: no cover - extremely unlikely
+    PackageNotFoundError = Exception  # type: ignore
+
+    def version(_: str) -> str:  # type: ignore
+        return "0.0.0.dev0"
+
+
+try:
+    import tomllib as _toml  # Python 3.11+
+except Exception:  # pragma: no cover
+    try:
+        import tomli as _toml  # type: ignore
+    except Exception:  # pragma: no cover
+        _toml = None  # type: ignore
+
+
+def _get_version() -> str:
+    try:
+        return version("glaip-sdk")
+    except PackageNotFoundError:
+        # Not installed; try reading from local pyproject for dev
+        if _toml is not None:
+            try:
+                from pathlib import Path
+
+                here = Path(__file__).resolve()
+                root = here.parent.parent  # project root (contains pyproject.toml)
+                pyproject = root / "pyproject.toml"
+                if pyproject.is_file():
+                    data = _toml.loads(pyproject.read_text(encoding="utf-8"))
+                    ver = data.get("project", {}).get("version") or data.get(
+                        "tool", {}
+                    ).get("poetry", {}).get("version")
+                    if isinstance(ver, str) and ver:
+                        return ver
+            except Exception:
+                pass
+        return "0.0.0.dev0"
+
+
+__version__ = _get_version()

glaip_sdk/cli/commands/agents.py

@@ -1,30 +1,42 @@
-"""Agent management commands.
+"""Agent CLI commands for AIP SDK.
 
 Authors:
     Raymond Christopher (raymond.christopher@gdplabs.id)
 """
 
 import json
+from datetime import datetime
 
 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 (
+    build_renderer,
+    coerce_to_row,
     get_client,
-    handle_ambiguous_resource,
     output_flags,
     output_list,
     output_result,
-    safe_getattr,
+    resolve_resource,
 )
 
 console = Console()
 
 
+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
+
+
 @click.group(name="agents", no_args_is_help=True)
 def agents_group():
     """Agent management operations."""
@@ -33,25 +45,14 @@ def agents_group():
 
 def _resolve_agent(ctx, client, ref, select=None):
     """Resolve agent reference (ID or name) with ambiguity handling."""
-    if is_uuid(ref):
-        return client.agents.get_agent_by_id(ref)
-
-    # Find agents by name
-    matches = client.agents.find_agents(name=ref)
-    if not matches:
-        raise click.ClickException(f"Agent '{ref}' not found")
-
-    if len(matches) == 1:
-        return matches[0]
-
-    # Multiple matches - handle ambiguity
-    if select:
-        idx = int(select) - 1
-        if not (0 <= idx < len(matches)):
-            raise click.ClickException(f"--select must be 1..{len(matches)}")
-        return matches[idx]
-
-    return handle_ambiguous_resource(ctx, "agent", ref, matches)
+    return resolve_resource(
+        ctx,
+        ref,
+        get_by_id=client.agents.get_agent_by_id,
+        find_by_name=client.agents.find_agents,
+        label="Agent",
+        select=select,
+    )
 
 
 @agents_group.command(name="list")
@@ -74,13 +75,10 @@ def list_agents(ctx):
 
         # Transform function for safe attribute access
         def transform_agent(agent):
-            return {
-                "id": str(agent.id),
-                "name": agent.name,
-                "type": safe_getattr(agent, "type") or "N/A",
-                "framework": safe_getattr(agent, "framework") or "N/A",
-                "version": safe_getattr(agent, "version") or "N/A",
-            }
+            row = coerce_to_row(agent, ["id", "name", "type", "framework", "version"])
+            # Ensure id is always a string
+            row["id"] = str(row["id"])
+            return row
 
         output_list(ctx, agents, "🤖 Available Agents", columns, transform_agent)
 
@@ -101,6 +99,16 @@ def get(ctx, agent_ref, select):
         # Resolve agent with ambiguity handling
         agent = _resolve_agent(ctx, client, agent_ref, select)
 
+        # If resolved by name, it may be a shallow object from list endpoint.
+        # Fetch full details by ID to ensure instruction/tools are populated.
+        try:
+            agent_id = str(getattr(agent, "id", "")).strip()
+            if agent_id:
+                agent = client.agents.get_agent_by_id(agent_id)
+        except Exception:
+            # If fetching full details fails, continue with the resolved object.
+            pass
+
         # Create result data with all available fields from backend
         result_data = {
             "id": str(getattr(agent, "id", "N/A")),
@@ -110,9 +118,12 @@ def get(ctx, agent_ref, select):
             "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": agent.tool_configs or {},
             "tools": getattr(agent, "tools", []),
             "agents": getattr(agent, "agents", []),
             "mcps": getattr(agent, "mcps", []),
@@ -128,27 +139,21 @@ def get(ctx, agent_ref, select):
 
 
 @agents_group.command()
-@click.argument("agent_id")
+@click.argument("agent_ref")
+@click.option("--select", type=int, help="Choose among ambiguous matches (1-based)")
 @click.option("--input", "input_text", required=True, help="Input text for the agent")
 @click.option("--chat-history", help="JSON string of chat history")
-@click.option("--timeout", default=600, type=int, help="Request timeout in seconds")
 @click.option(
-    "--view",
-    type=click.Choice(["rich", "plain", "json", "md"]),
-    default="rich",
-    help="Output view format",
-)
-@click.option(
-    "--compact/--verbose", default=True, help="Collapse tool steps (default: compact)"
+    "--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(
-    "--theme", type=click.Choice(["dark", "light"]), default="dark", help="Color theme"
-)
 @click.option(
     "--file",
     "files",
@@ -156,28 +161,30 @@ def get(ctx, agent_ref, select):
     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,
-    agent_id,
+    agent_ref,
+    select,
     input_text,
     chat_history,
     timeout,
-    view,
-    compact,
     save,
-    theme,
     files,
+    verbose,
 ):
-    """Run an agent with input text (ID required)."""
+    """Run an agent with input text (ID or name)."""
     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}")
+        # Resolve agent by ID or name (align with other commands)
+        agent = _resolve_agent(ctx, client, agent_ref, select)
 
         # Parse chat history if provided
         parsed_chat_history = None
@@ -187,85 +194,126 @@ def run(
             except json.JSONDecodeError:
                 raise click.ClickException("Invalid JSON in chat history")
 
-        # Always stream (no --no-stream option)
-        stream = ctx.obj.get("tty", True)
+        # Create custom renderer with CLI flags
+        tty_enabled = bool((ctx.obj or {}).get("tty", True))
 
-        # Create appropriate renderer based on view
-        renderer = None
-        if stream:
-            from ...utils.run_renderer import RichStreamRenderer
+        # Build renderer and capturing console
+        renderer, working_console = build_renderer(
+            ctx,
+            save_path=save,
+            verbose=verbose,
+            tty_enabled=tty_enabled,
+        )
 
-            # Use RichStreamRenderer for all streaming output
-            # Different view formats are handled in the output logic below
-            renderer = RichStreamRenderer(
-                console, verbose=not compact, theme=theme, use_emoji=True
-            )
+        # 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": input_text,
+            "files": list(files),
+            "agent_name": agent.name,  # Pass agent name for better display
+            "tty": tty_enabled,
+        }
 
-        # Run agent
-        result = client.agents.run_agent(
-            agent_id=agent.id,
-            message=input_text,
-            files=list(files),
-            stream=stream,
-            agent_name=agent.name,  # Pass agent name for better display
-            **({"chat_history": parsed_chat_history} if parsed_chat_history else {}),
-            **({"timeout": timeout} if timeout else {}),
-        )
+        # 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
+
+        # 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)
-        printed_by_renderer = bool(renderer and stream)
+        # 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 non-streaming or fallback
+        # Handle output format for fallback
         # Only print here if nothing was printed by the renderer
         if not printed_by_renderer:
-            if (ctx.obj.get("view") == "json") or (view == "json"):
+            if selected_view == "json":
                 click.echo(json.dumps({"output": result}, indent=2))
-            elif view == "md":
+            elif selected_view == "md":
                 click.echo(f"# Assistant\n\n{result}")
-            elif view == "plain":
+            elif selected_view == "plain":
                 click.echo(result)
-            elif not stream:
-                # Rich output for non-streaming
-                panel = Panel(
-                    Text(result, style="green"),
-                    title="Agent Output",
-                    border_style="green",
-                )
-                console.print(panel)
 
         # Save transcript if requested
-        if save and result:
+        if save:
             ext = (save.rsplit(".", 1)[-1] or "").lower()
             if ext == "json":
-                content = json.dumps({"output": result}, indent=2)
-                with open(save, "w", encoding="utf-8") as f:
-                    f.write(content)
+                # 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:
-                content = f"# Assistant\n\n{result}\n"
-                with open(save, "w", encoding="utf-8") as f:
-                    f.write(content)
-            console.print(f"[green]Transcript saved to: {save}[/green]")
-
+                # 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(f"[green]Full debug output saved to: {save}[/green]")
+
+    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
+        raise click.ClickException(error_msg)
     except Exception as e:
         if ctx.obj.get("view") == "json":
             click.echo(json.dumps({"error": str(e)}, indent=2))
-        else:
-            console.print(f"[red]Error running agent: {e}[/red]")
+        # Don't print the error message here - Click.ClickException will handle it
         raise click.ClickException(str(e))
 
 
 @agents_group.command()
 @click.option("--name", required=True, help="Agent name")
 @click.option("--instruction", required=True, help="Agent instruction (prompt)")
+@click.option(
+    "--model",
+    help=f"Language model to use (e.g., {DEFAULT_MODEL}, default: {DEFAULT_MODEL})",
+)
 @click.option("--tools", multiple=True, help="Tool names or IDs to attach")
-@click.option("--agents", multiple=True, help="Sub-agent names to attach")
-@click.option("--timeout", default=300, type=int, help="Execution timeout in seconds")
+@click.option("--agents", multiple=True, help="Sub-agent names or IDs to attach")
+@click.option(
+    "--timeout",
+    default=DEFAULT_AGENT_RUN_TIMEOUT,
+    type=int,
+    help="Agent execution timeout in seconds (default: 300s)",
+)
 @output_flags()
 @click.pass_context
 def create(
     ctx,
     name,
     instruction,
+    model,
     tools,
     agents,
     timeout,
@@ -273,14 +321,57 @@ def create(
     """Create a new agent."""
     try:
         client = get_client(ctx)
-        # Create agent (uses backend default model)
-        agent = client.agents.create_agent(
-            name=name,
-            instruction=instruction,
-            tools=list(tools),
-            agents=list(agents),
-            timeout=timeout,
-        )
+
+        # Resolve tool and agent references: accept names or IDs
+        def _resolve_tools(items: tuple[str, ...]) -> list[str]:
+            out: list[str] = []
+            for ref in list(items or ()):  # tuple -> list
+                if is_uuid(ref):
+                    out.append(ref)
+                    continue
+                matches = client.find_tools(name=ref)
+                if not matches:
+                    raise click.ClickException(f"Tool not found: {ref}")
+                if len(matches) > 1:
+                    raise click.ClickException(
+                        f"Multiple tools named '{ref}'. Use ID instead."
+                    )
+                out.append(str(matches[0].id))
+            return out
+
+        def _resolve_agents(items: tuple[str, ...]) -> list[str]:
+            out: list[str] = []
+            for ref in list(items or ()):  # tuple -> list
+                if is_uuid(ref):
+                    out.append(ref)
+                    continue
+                matches = client.find_agents(name=ref)
+                if not matches:
+                    raise click.ClickException(f"Agent not found: {ref}")
+                if len(matches) > 1:
+                    raise click.ClickException(
+                        f"Multiple agents named '{ref}'. Use ID instead."
+                    )
+                out.append(str(matches[0].id))
+            return out
+
+        resolved_tools = _resolve_tools(tools)
+        resolved_agents = _resolve_agents(agents)
+
+        # Create agent with optional model specification
+        create_kwargs = {
+            "name": name,
+            "instruction": instruction,
+            "tools": resolved_tools or None,
+            "agents": resolved_agents or None,
+            "timeout": timeout,
+        }
+
+        # Add model if specified
+        if model:
+            create_kwargs["model"] = model
+
+        agent = client.agents.create_agent(**create_kwargs)
 
         if ctx.obj.get("view") == "json":
             click.echo(json.dumps(agent.model_dump(), indent=2))
@@ -292,7 +383,8 @@ def create(
                 lm = (
                     cfg.get("lm_name")
                     or cfg.get("model")
-                    or "gpt-4.1 (backend default)"
+                    or model  # Use CLI model if specified
+                    or f"{DEFAULT_MODEL} (backend default)"
                 )
 
             panel = Panel(
@@ -352,7 +444,7 @@ def update(ctx, agent_id, name, instruction, tools, agents, timeout):
             raise click.ClickException("No update fields specified")
 
         # Update agent
-        updated_agent = client.agents.update_agent(agent.id, update_data)
+        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))

glaip_sdk/cli/commands/configure.py

@@ -14,6 +14,8 @@ from rich.console import Console
 from rich.panel import Panel
 from rich.table import Table
 
+from glaip_sdk import Client
+
 console = Console()
 
 CONFIG_DIR = Path.home() / ".aip"
@@ -25,8 +27,11 @@ def load_config():
     if not CONFIG_FILE.exists():
         return {}
 
-    with open(CONFIG_FILE) as f:
-        return yaml.safe_load(f) or {}
+    try:
+        with open(CONFIG_FILE) as f:
+            return yaml.safe_load(f) or {}
+    except yaml.YAMLError:
+        return {}
 
 
 def save_config(config):
@@ -49,82 +54,6 @@ def config_group():
     pass
 
 
-@config_group.command()
-def configure():
-    """Configure AIP CLI credentials and settings interactively."""
-
-    console.print(
-        Panel(
-            "[bold cyan]AIP Configuration[/bold cyan]\nConfigure your AIP CLI settings.",
-            title="🔧 Configuration Setup",
-            border_style="cyan",
-        )
-    )
-
-    # Load existing config
-    config = load_config()
-
-    console.print("\n[bold]Enter your AIP configuration:[/bold]")
-    console.print("(Leave blank to keep current values)")
-    console.print("─" * 50)
-
-    # API URL
-    current_url = config.get("api_url", "")
-    console.print(
-        f"\n[cyan]AIP API URL[/cyan] {f'(current: {current_url})' if current_url else ''}:"
-    )
-    new_url = input("> ").strip()
-    if new_url:
-        config["api_url"] = new_url
-    elif not current_url:
-        config["api_url"] = "https://your-aip-instance.com"
-
-    # API Key
-    current_key_masked = (
-        "***" + config.get("api_key", "")[-4:] if config.get("api_key") else ""
-    )
-    console.print(
-        f"\n[cyan]AIP API Key[/cyan] {f'(current: {current_key_masked})' if current_key_masked else ''}:"
-    )
-    new_key = getpass.getpass("> ")
-    if new_key:
-        config["api_key"] = new_key
-
-    # Save configuration
-    save_config(config)
-
-    console.print(f"\n✅ Configuration saved to: {CONFIG_FILE}")
-
-    # Test the new configuration
-    console.print("\n🔌 Testing connection...")
-    try:
-        from glaip_sdk import Client
-
-        # Create client with new config
-        client = Client(api_url=config["api_url"], api_key=config["api_key"])
-
-        # Try to list resources to test connection
-        try:
-            agents = client.list_agents()
-            console.print(f"✅ Connection successful! Found {len(agents)} agents")
-        except Exception as e:
-            console.print(f"⚠️  Connection established but API call failed: {e}")
-            console.print(
-                "   You may need to check your API permissions or network access"
-            )
-
-        client.close()
-
-    except Exception as e:
-        console.print(f"❌ Connection failed: {e}")
-        console.print("   Please check your API URL and key")
-        console.print("   You can run 'aip status' later to test again")
-
-    console.print("\n💡 You can now use AIP CLI commands!")
-    console.print("   • Run 'aip status' to check connection")
-    console.print("   • Run 'aip agents list' to see your agents")
-
-
 @config_group.command("list")
 def list_config():
     """List current configuration."""
@@ -237,13 +166,8 @@ def reset_config(force):
         console.print("[yellow]No configuration found to reset.[/yellow]")
 
 
-# Note: The config command group should be registered in main.py
-
-
-@click.command()
-def configure_command():
-    """Configure AIP CLI credentials and settings interactively."""
-
+def _configure_interactive():
+    """Shared configuration logic for both configure commands."""
     console.print(
         Panel(
             "[bold cyan]AIP Configuration[/bold cyan]\nConfigure your AIP CLI settings.",
@@ -289,8 +213,6 @@ def configure_command():
     # Test the new configuration
     console.print("\n🔌 Testing connection...")
     try:
-        from glaip_sdk import Client
-
         # Create client with new config
         client = Client(api_url=config["api_url"], api_key=config["api_key"])
 
@@ -314,3 +236,23 @@ def configure_command():
     console.print("\n💡 You can now use AIP CLI commands!")
     console.print("   • Run 'aip status' to check connection")
     console.print("   • Run 'aip agents list' to see your agents")
+
+
+@config_group.command()
+def configure():
+    """Configure AIP CLI credentials and settings interactively."""
+    _configure_interactive()
+
+
+# Alias command for backward compatibility
+@click.command()
+def configure_command():
+    """Configure AIP CLI credentials and settings interactively.
+
+    This is an alias for 'aip config configure' for backward compatibility.
+    """
+    # Delegate to the shared function
+    _configure_interactive()
+
+
+# Note: The config command group should be registered in main.py