glaip-sdk 0.6.0__py3-none-any.whl → 0.6.2__py3-none-any.whl

glaip_sdk/agents/base.py

@@ -44,12 +44,14 @@ from __future__ import annotations
 
 import inspect
 import logging
+import warnings
 from collections.abc import AsyncGenerator
 from pathlib import Path
 from typing import TYPE_CHECKING, Any
 
 from glaip_sdk.registry import get_agent_registry, get_mcp_registry, get_tool_registry
 from glaip_sdk.utils.discovery import find_agent
+from glaip_sdk.utils.runtime_config import normalize_runtime_config_keys
 
 if TYPE_CHECKING:
     from glaip_sdk.models import AgentResponse
@@ -127,16 +129,8 @@ class Agent:
         agents: list | None = None,
         mcps: list | None = None,
         model: str | None = _UNSET,  # type: ignore[assignment]
-        timeout: int | None = _UNSET,  # type: ignore[assignment]
-        metadata: dict[str, Any] | None = _UNSET,  # type: ignore[assignment]
-        framework: str | None = _UNSET,  # type: ignore[assignment]
-        version: str | None = _UNSET,  # type: ignore[assignment]
-        agent_type: str | None = _UNSET,  # type: ignore[assignment]
-        agent_config: dict[str, Any] | None = _UNSET,  # type: ignore[assignment]
-        tool_configs: dict[str, Any] | None = _UNSET,  # type: ignore[assignment]
-        mcp_configs: dict[str, Any] | None = _UNSET,  # type: ignore[assignment]
-        a2a_profile: dict[str, Any] | None = _UNSET,  # type: ignore[assignment]
         _client: Any = None,
+        **kwargs: Any,
     ) -> None:
         """Initialize an Agent.
 
@@ -152,16 +146,17 @@ class Agent:
             agents: List of sub-agents (Agent classes, instances, or strings).
             mcps: List of MCPs.
             model: Model identifier.
-            timeout: Execution timeout in seconds.
-            metadata: Optional metadata dictionary.
-            framework: Agent framework identifier.
-            version: Agent version string.
-            agent_type: Agent type identifier.
-            agent_config: Agent execution configuration.
-            tool_configs: Per-tool configuration overrides.
-            mcp_configs: Per-MCP configuration overrides.
-            a2a_profile: A2A profile configuration.
             _client: Internal client reference (set automatically).
+            **kwargs: Additional configuration parameters:
+                - timeout: Execution timeout in seconds.
+                - metadata: Optional metadata dictionary.
+                - framework: Agent framework identifier.
+                - version: Agent version string.
+                - agent_type: Agent type identifier.
+                - agent_config: Agent execution configuration.
+                - tool_configs: Per-tool configuration overrides.
+                - mcp_configs: Per-MCP configuration overrides.
+                - a2a_profile: A2A profile configuration.
         """
         # Instance attributes for deployed agents
         self._id = id
@@ -178,15 +173,24 @@ class Agent:
         self._mcps = mcps
         self._model = model
         self._language_model_id: str | None = None
-        self._timeout = timeout
-        self._metadata = metadata
-        self._framework = framework
-        self._version = version
-        self._agent_type = agent_type
-        self._agent_config = agent_config
-        self._tool_configs = tool_configs
-        self._mcp_configs = mcp_configs
-        self._a2a_profile = a2a_profile
+        # Extract parameters from kwargs with _UNSET defaults
+        self._timeout = kwargs.pop("timeout", Agent._UNSET)  # type: ignore[assignment]
+        self._metadata = kwargs.pop("metadata", Agent._UNSET)  # type: ignore[assignment]
+        self._framework = kwargs.pop("framework", Agent._UNSET)  # type: ignore[assignment]
+        self._version = kwargs.pop("version", Agent._UNSET)  # type: ignore[assignment]
+        self._agent_type = kwargs.pop("agent_type", Agent._UNSET)  # type: ignore[assignment]
+        self._agent_config = kwargs.pop("agent_config", Agent._UNSET)  # type: ignore[assignment]
+        self._tool_configs = kwargs.pop("tool_configs", Agent._UNSET)  # type: ignore[assignment]
+        self._mcp_configs = kwargs.pop("mcp_configs", Agent._UNSET)  # type: ignore[assignment]
+        self._a2a_profile = kwargs.pop("a2a_profile", Agent._UNSET)  # type: ignore[assignment]
+
+        # Warn about unexpected kwargs
+        if kwargs:
+            warnings.warn(
+                f"Unexpected keyword arguments: {list(kwargs.keys())}. These will be ignored.",
+                UserWarning,
+                stacklevel=2,
+            )
 
     # ─────────────────────────────────────────────────────────────────
     # Properties (override in subclasses OR pass to __init__)
@@ -792,21 +796,23 @@ class Agent:
         self._client = client
         return self
 
-    def run(
+    def _prepare_run_kwargs(
         self,
         message: str,
-        verbose: bool = False,
+        verbose: bool,
+        runtime_config: dict[str, Any] | None,
         **kwargs: Any,
-    ) -> str:
-        """Run the agent synchronously with a message.
+    ) -> tuple[Any, dict[str, Any]]:
+        """Prepare common arguments for run/arun methods.
 
         Args:
             message: The message to send to the agent.
             verbose: If True, print streaming output to console.
+            runtime_config: Optional runtime configuration.
             **kwargs: Additional arguments to pass to the run API.
 
         Returns:
-            The agent's response as a string.
+            Tuple of (agent_client, call_kwargs).
 
         Raises:
             ValueError: If the agent hasn't been deployed yet.
@@ -817,24 +823,77 @@ class Agent:
         if not self._client:
             raise RuntimeError(_CLIENT_NOT_AVAILABLE_MSG)
 
-        # _client can be either main Client or AgentClient
         agent_client = getattr(self._client, "agents", self._client)
-        return agent_client.run_agent(
-            agent_id=self.id,
-            message=message,
-            verbose=verbose,
-            **kwargs,
+
+        call_kwargs: dict[str, Any] = {
+            "agent_id": self.id,
+            "message": message,
+            "verbose": verbose,
+        }
+
+        if runtime_config is not None:
+            call_kwargs["runtime_config"] = normalize_runtime_config_keys(
+                runtime_config,
+                tool_registry=get_tool_registry(),
+                mcp_registry=get_mcp_registry(),
+                agent_registry=get_agent_registry(),
+            )
+
+        call_kwargs.update(kwargs)
+        return agent_client, call_kwargs
+
+    def run(
+        self,
+        message: str,
+        verbose: bool = False,
+        runtime_config: dict[str, Any] | None = None,
+        **kwargs: Any,
+    ) -> str:
+        """Run the agent synchronously with a message.
+
+        Args:
+            message: The message to send to the agent.
+            verbose: If True, print streaming output to console.
+            runtime_config: Optional runtime configuration for tools, MCPs, and agents.
+                Keys can be SDK objects, UUIDs, or names. Example:
+                {
+                    "tool_configs": {"tool-id": {"param": "value"}},
+                    "mcp_configs": {"mcp-id": {"setting": "on"}},
+                    "agent_config": {"planning": True},
+                }
+            **kwargs: Additional arguments to pass to the run API.
+
+        Returns:
+            The agent's response as a string.
+
+        Raises:
+            ValueError: If the agent hasn't been deployed yet.
+            RuntimeError: If client is not available.
+        """
+        agent_client, call_kwargs = self._prepare_run_kwargs(
+            message, verbose, runtime_config or kwargs.get("runtime_config"), **kwargs
         )
+        return agent_client.run_agent(**call_kwargs)
 
     async def arun(
         self,
         message: str,
+        verbose: bool = False,
+        runtime_config: dict[str, Any] | None = None,
         **kwargs: Any,
     ) -> AsyncGenerator[dict, None]:
         """Run the agent asynchronously with streaming output.
 
         Args:
             message: The message to send to the agent.
+            verbose: If True, print streaming output to console.
+            runtime_config: Optional runtime configuration for tools, MCPs, and agents.
+                Keys can be SDK objects, UUIDs, or names. Example:
+                {
+                    "tool_configs": {"tool-id": {"param": "value"}},
+                    "mcp_configs": {"mcp-id": {"setting": "on"}},
+                    "agent_config": {"planning": True},
+                }
             **kwargs: Additional arguments to pass to the run API.
 
         Yields:
@@ -844,18 +903,10 @@ class Agent:
             ValueError: If the agent hasn't been deployed yet.
             RuntimeError: If client is not available.
         """
-        if not self.id:
-            raise ValueError(_AGENT_NOT_DEPLOYED_MSG)
-        if not self._client:
-            raise RuntimeError(_CLIENT_NOT_AVAILABLE_MSG)
-
-        # _client can be either main Client or AgentClient
-        agent_client = getattr(self._client, "agents", self._client)
-        async for chunk in agent_client.arun_agent(
-            agent_id=self.id,
-            message=message,
-            **kwargs,
-        ):
+        agent_client, call_kwargs = self._prepare_run_kwargs(
+            message, verbose, runtime_config or kwargs.get("runtime_config"), **kwargs
+        )
+        async for chunk in agent_client.arun_agent(**call_kwargs):
             yield chunk
 
     def update(self, **kwargs: Any) -> Agent:
@@ -880,13 +931,17 @@ class Agent:
         agent_client = getattr(self._client, "agents", self._client)
         response = agent_client.update_agent(agent_id=self.id, **kwargs)
 
-        # Update local properties from response
-        if hasattr(response, "name") and response.name:
-            self.name = response.name
-        if hasattr(response, "instruction") and response.instruction:
-            self.instruction = response.instruction
-        if hasattr(response, "updated_at"):
-            self.updated_at = response.updated_at
+        # Update local properties from response (read-only props via private attrs)
+        name = getattr(response, "name", None)
+        if name:
+            self._name = name
+
+        instruction = getattr(response, "instruction", None)
+        if instruction:
+            self._instruction = instruction
+
+        # Populate remaining fields like description, metadata, updated_at, etc.
+        type(self)._populate_from_response(self, response)
 
         return self
 

glaip_sdk/cli/commands/common_config.py

@@ -1,6 +1,7 @@
 """Shared helpers for configuration/account flows."""
 
 import click
+import logging
 from rich.console import Console
 from rich.text import Text
 
@@ -63,3 +64,38 @@ def check_connection(
     finally:
         if client is not None:
             client.close()
+
+
+def check_connection_with_reason(
+    api_url: str,
+    api_key: str,
+    *,
+    abort_on_error: bool = False,
+) -> tuple[bool, str]:
+    """Test connectivity and return structured reason."""
+    client: Client | None = None
+    try:
+        # Import lazily so test patches targeting glaip_sdk.Client are honored
+        from importlib import import_module  # noqa: PLC0415
+
+        client_module = import_module("glaip_sdk")
+        client = client_module.Client(api_url=api_url, api_key=api_key)
+        try:
+            client.list_agents()
+            return True, ""
+        except Exception as exc:  # pragma: no cover - API failures depend on network
+            if abort_on_error:
+                raise click.Abort() from exc
+            return False, f"api_failed: {exc}"
+    except Exception as exc:
+        # Log unexpected exceptions in debug while keeping CLI-friendly messaging
+        logging.getLogger(__name__).debug("Unexpected connection error", exc_info=exc)
+        if abort_on_error:
+            raise click.Abort() from exc
+        return False, f"connection_failed: {exc}"
+    finally:
+        if client is not None:
+            try:
+                client.close()
+            except Exception:
+                pass

glaip_sdk/cli/config.py

@@ -12,15 +12,26 @@ from typing import Any
 import yaml
 
 _ENV_CONFIG_DIR = os.getenv("AIP_CONFIG_DIR")
-_TEST_ENV = os.getenv("PYTEST_CURRENT_TEST") or os.getenv("PYTEST_XDIST_WORKER")
+# Detect pytest environment: check for pytest markers or test session
+# This provides automatic test isolation even if conftest.py doesn't set AIP_CONFIG_DIR
+# Note: conftest.py sets AIP_CONFIG_DIR before imports, which takes precedence
+_TEST_ENV = os.getenv("PYTEST_CURRENT_TEST") or os.getenv("PYTEST_XDIST_WORKER") or os.getenv("_PYTEST_RAISE")
 
 if _ENV_CONFIG_DIR:
+    # Explicit override via environment variable (highest priority)
+    # This is set by conftest.py before imports, ensuring test isolation
     CONFIG_DIR = Path(_ENV_CONFIG_DIR)
 elif _TEST_ENV:
     # Isolate test runs (including xdist workers) from the real user config directory
+    # Use a per-process unique temp directory to avoid conflicts in parallel test runs
     import tempfile
+    import uuid
 
-    CONFIG_DIR = Path(tempfile.gettempdir()) / "aip-test-config"
+    # Create a unique temp dir per test process to avoid conflicts
+    temp_base = Path(tempfile.gettempdir())
+    test_config_dir = temp_base / f"aip-test-config-{os.getpid()}-{uuid.uuid4().hex[:8]}"
+    CONFIG_DIR = test_config_dir
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
 else:  # pragma: no cover - default path used outside test runs
     CONFIG_DIR = Path.home() / ".aip"
 

glaip_sdk/cli/main.py

@@ -49,6 +49,24 @@ from glaip_sdk.config.constants import (
 from glaip_sdk.icons import ICON_AGENT
 from glaip_sdk.rich_components import AIPPanel, AIPTable
 
+
+def _suppress_chatty_loggers() -> None:
+    """Silence noisy SDK/httpx logs for CLI output."""
+    noisy_loggers = [
+        "glaip_sdk.client",
+        "httpx",
+        "httpcore",
+    ]
+    for name in noisy_loggers:
+        logger = logging.getLogger(name)
+        # Respect existing configuration: only raise level when unset,
+        # and avoid changing propagation if a custom handler is already attached.
+        if logger.level == logging.NOTSET:
+            logger.setLevel(logging.WARNING)
+        if not logger.handlers:
+            logger.propagate = False
+
+
 # Import SlashSession for potential mocking in tests
 try:
     from glaip_sdk.cli.slash import SlashSession
@@ -123,6 +141,8 @@ def main(
     ctx.obj["view"] = view
     ctx.obj["account_name"] = account_name
 
+    _suppress_chatty_loggers()
+
     ctx.obj["tty"] = not no_tty
 
     launching_slash = (

glaip_sdk/cli/slash/accounts_controller.py

@@ -0,0 +1,217 @@
+"""Accounts controller for the /accounts slash command.
+
+Provides a lightweight Textual list with fallback Rich snapshot to switch
+between stored accounts using the shared AccountStore and CLI validation.
+
+Authors:
+    Raymond Christopher (raymond.christopher@gdplabs.id)
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+from collections.abc import Iterable
+from typing import TYPE_CHECKING, Any
+
+from rich.console import Console
+
+from glaip_sdk.branding import ERROR_STYLE, INFO_STYLE, SUCCESS_STYLE, WARNING_STYLE
+from glaip_sdk.cli.account_store import AccountStore, AccountStoreError, get_account_store
+from glaip_sdk.cli.commands.common_config import check_connection_with_reason
+from glaip_sdk.cli.masking import mask_api_key_display
+from glaip_sdk.cli.slash.accounts_shared import build_account_status_string
+from glaip_sdk.cli.slash.tui.accounts_app import TEXTUAL_SUPPORTED, AccountsTUICallbacks, run_accounts_textual
+from glaip_sdk.rich_components import AIPPanel, AIPTable
+
+if TYPE_CHECKING:  # pragma: no cover
+    from glaip_sdk.cli.slash.session import SlashSession
+
+TEXTUAL_AVAILABLE = bool(TEXTUAL_SUPPORTED)
+
+
+class AccountsController:
+    """Controller for listing and switching accounts inside the palette."""
+
+    def __init__(self, session: SlashSession) -> None:
+        """Initialize the accounts controller.
+
+        Args:
+            session: The slash session context.
+        """
+        self.session = session
+        self.console: Console = session.console
+        self.ctx = session.ctx
+
+    def handle_accounts_command(self, args: list[str]) -> bool:
+        """Handle `/accounts` with optional `/accounts <name>` quick switch."""
+        store = get_account_store()
+        env_lock = bool(os.getenv("AIP_API_URL") or os.getenv("AIP_API_KEY"))
+        accounts = store.list_accounts()
+
+        if not accounts:
+            self.console.print(f"[{WARNING_STYLE}]No accounts found. Use `/login` to add credentials.[/]")
+            return self.session._continue_session()
+
+        if args:
+            name = args[0]
+            self._switch_account(store, name, env_lock)
+            return self.session._continue_session()
+
+        rows = self._build_rows(accounts, store.get_active_account(), env_lock)
+
+        if self._should_use_textual():
+            self._render_textual(rows, store, env_lock)
+        else:
+            self._render_rich(rows, env_lock)
+
+        return self.session._continue_session()
+
+    def _should_use_textual(self) -> bool:
+        """Return whether Textual UI should be used."""
+        if not TEXTUAL_AVAILABLE:
+            return False
+
+        def _is_tty(stream: Any) -> bool:
+            isatty = getattr(stream, "isatty", None)
+            if not callable(isatty):
+                return False
+            try:
+                return bool(isatty())
+            except Exception:
+                return False
+
+        return _is_tty(sys.stdin) and _is_tty(sys.stdout)
+
+    def _build_rows(
+        self,
+        accounts: dict[str, dict[str, str]],
+        active_account: str | None,
+        env_lock: bool,
+    ) -> list[dict[str, str | bool]]:
+        """Normalize account rows for display."""
+        rows: list[dict[str, str | bool]] = []
+        for name, account in sorted(accounts.items()):
+            rows.append(
+                {
+                    "name": name,
+                    "api_url": account.get("api_url", ""),
+                    "masked_key": mask_api_key_display(account.get("api_key", "")),
+                    "active": name == active_account,
+                    "env_lock": env_lock,
+                }
+            )
+        return rows
+
+    def _render_rich(self, rows: Iterable[dict[str, str | bool]], env_lock: bool) -> None:
+        """Render a Rich snapshot with columns matching TUI."""
+        if env_lock:
+            self.console.print(
+                f"[{WARNING_STYLE}]Env credentials detected (AIP_API_URL/AIP_API_KEY); switching is disabled.[/]"
+            )
+
+        table = AIPTable(title="AIP Accounts")
+        table.add_column("Name", style=INFO_STYLE, width=20)
+        table.add_column("API URL", style=SUCCESS_STYLE, width=40)
+        table.add_column("Key (masked)", style="dim", width=20)
+        table.add_column("Status", style=SUCCESS_STYLE, width=14)
+
+        for row in rows:
+            status = build_account_status_string(row, use_markup=True)
+            # pylint: disable=duplicate-code
+            # Similar to accounts_app.py but uses Rich AIPTable API
+            table.add_row(
+                str(row.get("name", "")),
+                str(row.get("api_url", "")),
+                str(row.get("masked_key", "")),
+                status,
+            )
+
+        self.console.print(table)
+
+    def _render_textual(self, rows: list[dict[str, str | bool]], store: AccountStore, env_lock: bool) -> None:
+        """Launch the Textual accounts browser."""
+        callbacks = AccountsTUICallbacks(switch_account=lambda name: self._switch_account(store, name, env_lock))
+        active = next((row["name"] for row in rows if row.get("active")), None)
+        run_accounts_textual(rows, active_account=active, env_lock=env_lock, callbacks=callbacks)
+        # Exit snapshot: show active account + host after closing the TUI
+        active_after = store.get_active_account() or "default"
+        host_after = ""
+        account_after = store.get_account(active_after) if hasattr(store, "get_account") else None
+        if account_after:
+            host_after = account_after.get("api_url", "")
+        host_suffix = f" • {host_after}" if host_after else ""
+        self.console.print(f"[dim]Active account: {active_after}{host_suffix}[/]")
+        # Surface a success banner when a switch occurred inside the TUI
+        if active_after != active:
+            self.console.print(
+                AIPPanel(
+                    f"[{SUCCESS_STYLE}]Active account ➜ {active_after}[/]{host_suffix}",
+                    title="✅ Account Switched",
+                    border_style=SUCCESS_STYLE,
+                )
+            )
+
+    def _switch_account(self, store: AccountStore, name: str, env_lock: bool) -> tuple[bool, str]:
+        """Validate and switch active account; returns (success, message)."""
+        if env_lock:
+            msg = "Env credentials detected (AIP_API_URL/AIP_API_KEY); switching is disabled."
+            self.console.print(f"[{WARNING_STYLE}]{msg}[/]")
+            return False, msg
+
+        account = store.get_account(name)
+        if not account:
+            msg = f"Account '{name}' not found."
+            self.console.print(f"[{ERROR_STYLE}]{msg}[/]")
+            return False, msg
+
+        api_url = account.get("api_url", "")
+        api_key = account.get("api_key", "")
+        if not api_url or not api_key:
+            edit_cmd = f"aip accounts edit {name}"
+            msg = f"Account '{name}' is missing credentials. Use `/login` or `{edit_cmd}`."
+            self.console.print(f"[{ERROR_STYLE}]{msg}[/]")
+            return False, msg
+
+        ok, error_reason = check_connection_with_reason(api_url, api_key, abort_on_error=False)
+        if not ok:
+            code, detail = self._parse_error_reason(error_reason)
+            if code == "connection_failed":
+                msg = f"Switch aborted: cannot reach {api_url}. Check URL or network."
+            elif code == "api_failed":
+                msg = f"Switch aborted: API error for '{name}'. Check credentials."
+            else:
+                detail_suffix = f": {detail}" if detail else ""
+                msg = f"Switch aborted: {code or 'Validation failed'}{detail_suffix}"
+            self.console.print(f"[{WARNING_STYLE}]{msg}[/]")
+            return False, msg
+
+        try:
+            store.set_active_account(name)
+            masked_key = mask_api_key_display(api_key)
+            self.console.print(
+                AIPPanel(
+                    f"[{SUCCESS_STYLE}]Active account ➜ {name}[/]\nAPI URL: {api_url}\nKey: {masked_key}",
+                    title="✅ Account Switched",
+                    border_style=SUCCESS_STYLE,
+                )
+            )
+            return True, f"Switched to '{name}'."
+        except AccountStoreError as exc:
+            msg = f"Failed to set active account: {exc}"
+            self.console.print(f"[{ERROR_STYLE}]{msg}[/]")
+            return False, msg
+        except Exception as exc:  # NOSONAR(S1045) - catch-all needed for unexpected errors
+            msg = f"Unexpected error while switching to '{name}': {exc}"
+            self.console.print(f"[{ERROR_STYLE}]{msg}[/]")
+            return False, msg
+
+    @staticmethod
+    def _parse_error_reason(reason: str | None) -> tuple[str, str]:
+        """Parse error reason into (code, detail) to avoid fragile substring checks."""
+        if not reason:
+            return "", ""
+        if ":" in reason:
+            code, _, detail = reason.partition(":")
+            return code.strip(), detail.strip()
+        return reason.strip(), ""

glaip_sdk/cli/slash/accounts_shared.py

@@ -0,0 +1,19 @@
+"""Shared helpers for palette `/accounts`.
+
+Authors:
+    Raymond Christopher (raymond.christopher@gdplabs.id)
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+def build_account_status_string(row: dict[str, Any], *, use_markup: bool = False) -> str:
+    """Build status string for an account row (active/env-lock)."""
+    status_parts: list[str] = []
+    if row.get("active"):
+        status_parts.append("[bold green]● active[/]" if use_markup else "● active")
+    if row.get("env_lock"):
+        status_parts.append("[yellow]🔒 env-lock[/]" if use_markup else "🔒 env-lock")
+    return " · ".join(status_parts)