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

glaip_sdk/agents/base.py

@@ -51,10 +51,12 @@ 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.resource_refs import is_uuid
 from glaip_sdk.utils.runtime_config import normalize_runtime_config_keys
 
 if TYPE_CHECKING:
     from glaip_sdk.models import AgentResponse
+    from glaip_sdk.registry import AgentRegistry, MCPRegistry, ToolRegistry
 
 logger = logging.getLogger(__name__)
 
@@ -519,7 +521,7 @@ class Agent:
 
         return self
 
-    def _build_config(self, tool_registry: Any, mcp_registry: Any) -> dict[str, Any]:
+    def _build_config(self, tool_registry: ToolRegistry, mcp_registry: MCPRegistry) -> dict[str, Any]:
         """Build the base configuration dictionary.
 
         Args:
@@ -558,9 +560,9 @@ class Agent:
         if self.mcps:
             config["mcps"] = self._resolve_mcps(mcp_registry)
 
-        # Handle mcp_configs
+        # Handle mcp_configs - normalize keys to MCP IDs
         if self.mcp_configs:
-            config["mcp_configs"] = self.mcp_configs
+            config["mcp_configs"] = self._resolve_mcp_configs(mcp_registry)
 
         # Handle a2a_profile
         if self.a2a_profile:
@@ -568,7 +570,7 @@ class Agent:
 
         return config
 
-    def _resolve_mcps(self, registry: Any) -> list[str]:
+    def _resolve_mcps(self, registry: MCPRegistry) -> list[str]:
         """Resolve MCP references to IDs using MCPRegistry.
 
         Uses the global MCPRegistry to cache MCP objects across deployments.
@@ -586,7 +588,7 @@ class Agent:
 
         return [registry.resolve(mcp_ref).id for mcp_ref in self.mcps]
 
-    def _resolve_tools(self, registry: Any) -> list[str]:
+    def _resolve_tools(self, registry: ToolRegistry) -> list[str]:
         """Resolve tool references to IDs using ToolRegistry.
 
         Uses the global ToolRegistry to cache Tool objects across deployments.
@@ -605,7 +607,7 @@ class Agent:
         # Resolve each tool reference to a Tool object, extract ID
         return [registry.resolve(tool_ref).id for tool_ref in self.tools]
 
-    def _resolve_tool_configs(self, registry: Any) -> dict[str, Any]:
+    def _resolve_tool_configs(self, registry: ToolRegistry) -> dict[str, Any]:
         """Resolve tool_configs keys from tool names/classes to tool IDs.
 
         Allows tool_configs to be defined with tool names, class names, or
@@ -639,7 +641,7 @@ class Agent:
 
         for key, config in self.tool_configs.items():
             # If key is already a UUID-like string, pass through
-            if isinstance(key, str) and len(key) == 36 and "-" in key:
+            if isinstance(key, str) and is_uuid(key):
                 resolved[key] = config
                 continue
 
@@ -652,7 +654,51 @@ class Agent:
 
         return resolved
 
-    def _resolve_agents(self, registry: Any) -> list:
+    def _resolve_mcp_configs(self, registry: MCPRegistry) -> dict[str, Any]:
+        """Resolve mcp_configs keys from MCP names/objects to MCP IDs.
+
+        Allows mcp_configs to be defined with MCP names, MCP objects, or UUIDs
+        as keys. Keys are resolved to MCP IDs using the MCPRegistry.
+
+        Supported key formats:
+            - MCP object (with id): uses id directly
+            - MCP name string: resolved via registry to ID
+            - MCP ID (UUID string): passed through unchanged
+
+        Args:
+            registry: The MCP registry.
+
+        Returns:
+            Dict with resolved MCP IDs as keys and configs as values.
+        """
+        if not self.mcp_configs:
+            return {}
+
+        resolved: dict[str, Any] = {}
+
+        for key, config in self.mcp_configs.items():
+            try:
+                # If key is already a UUID-like string, pass through
+                if isinstance(key, str) and is_uuid(key):
+                    resolved_id = key
+                else:
+                    mcp = registry.resolve(key)
+                    resolved_id = mcp.id
+
+                if resolved_id in resolved:
+                    raise ValueError(
+                        f"Duplicate mcp_configs entries resolve to the same MCP id '{resolved_id}' (key={key!r})"
+                    )
+
+                resolved[resolved_id] = config
+            except (ValueError, KeyError) as exc:
+                raise ValueError(
+                    f"Failed to resolve mcp config key {key!r} (type={type(key).__name__}): {exc}"
+                ) from exc
+
+        return resolved
+
+    def _resolve_agents(self, registry: AgentRegistry) -> list:
         """Resolve sub-agent references using AgentRegistry.
 
         Uses the global AgentRegistry to cache Agent objects across deployments.

glaip_sdk/cli/account_store.py

@@ -217,13 +217,14 @@ class AccountStore:
             api_key: API key or None.
 
         Returns:
-            Dictionary with "default" account if credentials exist, empty dict otherwise.
+            Dictionary with "default" account if both credentials exist and are non-empty, empty dict otherwise.
         """
         accounts = {}
-        if api_url or api_key:
+        # Only create default account if both URL and key are present and non-empty
+        if api_url and api_key and api_url.strip() and api_key.strip():
             accounts["default"] = {
-                "api_url": api_url or "",
-                "api_key": api_key or "",
+                "api_url": api_url.strip(),
+                "api_key": api_key.strip(),
             }
         return accounts
 
@@ -257,15 +258,30 @@ class AccountStore:
             "accounts": {},
         }
 
-        # Extract legacy api_url and api_key
-        api_url = config.get("api_url")
-        api_key = config.get("api_key")
+        # Preserve existing accounts if they exist (shouldn't happen in true migration, but defensive)
+        existing_accounts = config.get("accounts", {})
+        if existing_accounts:
+            migrated["accounts"] = existing_accounts.copy()
+            existing_active = config.get("active_account")
+            if existing_active and existing_active in existing_accounts:
+                migrated["active_account"] = existing_active
+            elif "default" in existing_accounts:
+                migrated["active_account"] = "default"
+            else:
+                migrated["active_account"] = sorted(existing_accounts.keys())[0]
+        else:
+            # Extract legacy api_url and api_key only if no accounts exist
+            api_url = config.get("api_url")
+            api_key = config.get("api_key")
 
-        # Check for auth.json from secure login MVP (only during migration)
-        api_url, api_key = self._load_auth_json_credentials(api_url, api_key)
+            # Check for auth.json from secure login MVP (only during migration)
+            api_url, api_key = self._load_auth_json_credentials(api_url, api_key)
 
-        # Create default account if we have credentials
-        migrated["accounts"] = self._create_default_account(api_url, api_key)
+            # Create default account if we have valid credentials
+            migrated["accounts"] = self._create_default_account(api_url, api_key)
+            # Only set active_account to default if we actually created a default account
+            if not migrated["accounts"]:
+                migrated.pop("active_account", None)
 
         # Preserve other top-level keys for backward compatibility
         migrated.update(self._preserve_legacy_keys(config))
@@ -423,16 +439,18 @@ class AccountStore:
 
         del accounts[name]
 
-        # If we removed the active account, switch to another
+        # If we removed the active account, switch to another account
         active_account = config.get("active_account")
         if active_account == name:
-            # Try to switch to 'default' if it exists, otherwise first alphabetical
-            remaining_names = sorted(accounts.keys())
-            if "default" in remaining_names:
+            # Prefer "default" if it exists, otherwise use first alphabetical account
+            if "default" in accounts:
                 config["active_account"] = "default"
-            elif remaining_names:
-                config["active_account"] = remaining_names[0]
-            else:  # pragma: no cover - defensive code, unreachable due to len check above
+            elif accounts:
+                # Sort accounts alphabetically and pick the first one
+                sorted_names = sorted(accounts.keys())
+                config["active_account"] = sorted_names[0]
+            else:
+                # No accounts remaining (shouldn't happen due to check above)
                 config.pop("active_account", None)
 
         self._save_config(config)

glaip_sdk/cli/auth.py

@@ -460,7 +460,7 @@ def _prompt_secret_with_placeholder(
         )
 
     attempts = 0
-    while attempts <= retry_limit:
+    while attempts <= retry_limit:  # pragma: no cover
         response = click.prompt(
             prompt_message,
             default="",

glaip_sdk/cli/commands/accounts.py

@@ -6,7 +6,6 @@ Authors:
 
 import getpass
 import json
-import os
 import sys
 from pathlib import Path
 
@@ -33,6 +32,7 @@ from glaip_sdk.cli.account_store import (
 from glaip_sdk.cli.commands.common_config import check_connection, render_branding_header
 from glaip_sdk.cli.hints import format_command_hint
 from glaip_sdk.cli.masking import mask_api_key_display
+from glaip_sdk.cli.slash.accounts_shared import env_credentials_present
 from glaip_sdk.cli.utils import command_hint
 from glaip_sdk.icons import ICON_TOOL
 from glaip_sdk.rich_components import AIPPanel, AIPTable
@@ -231,7 +231,7 @@ def show_account(name: str, output_json: bool) -> None:
     masked_key = _mask_api_key(api_key or "")
     active_account = store.get_active_account()
     is_active = active_account == name
-    env_lock = bool(os.getenv("AIP_API_URL") or os.getenv("AIP_API_KEY"))
+    env_lock = env_credentials_present(partial=True)
     config_path_raw = str(store.config_file)
     config_path_display = _format_config_path(config_path_raw)
 

glaip_sdk/cli/core/__init__.py

@@ -0,0 +1,79 @@
+"""CLI core modules for glaip-sdk.
+
+This package contains focused modules extracted from the monolithic cli/utils.py:
+- context: Click context helpers, config loading, credential resolution
+- prompting: prompt_toolkit + questionary wrappers, validators
+- rendering: Rich console helpers, viewer launchers, renderer builders
+- output: Table/console output utilities, list rendering
+
+Authors:
+    Raymond Christopher (raymond.christopher@gdplabs.id)
+    Putu Ravindra Wiguna (putu.r.wiguna@gdplabs.id)
+"""  # pylint: disable=duplicate-code
+
+from __future__ import annotations
+
+# Re-export all public APIs from submodules for convenience
+from glaip_sdk.cli.core.context import (
+    bind_slash_session_context,
+    get_client,
+    handle_best_effort_check,
+    restore_slash_session_context,
+)
+from glaip_sdk.cli.core.output import (
+    coerce_to_row,
+    detect_export_format,
+    fetch_resource_for_export,
+    format_datetime_fields,
+    format_size,
+    handle_resource_export,
+    output_list,
+    output_result,
+    parse_json_line,
+    resolve_resource,
+    handle_ambiguous_resource,
+    sdk_version,
+)
+from glaip_sdk.cli.core.prompting import (
+    _fuzzy_pick_for_resources,
+    prompt_export_choice_questionary,
+    questionary_safe_ask,
+)
+from glaip_sdk.cli.core.rendering import (
+    build_renderer,
+    spinner_context,
+    stop_spinner,
+    update_spinner,
+    with_client_and_spinner,
+)
+
+__all__ = [
+    # Context
+    "bind_slash_session_context",
+    "get_client",
+    "handle_best_effort_check",
+    "restore_slash_session_context",
+    # Prompting
+    "_fuzzy_pick_for_resources",
+    "prompt_export_choice_questionary",
+    "questionary_safe_ask",
+    # Rendering
+    "build_renderer",
+    "spinner_context",
+    "stop_spinner",
+    "update_spinner",
+    "with_client_and_spinner",
+    # Output
+    "coerce_to_row",
+    "detect_export_format",
+    "fetch_resource_for_export",
+    "format_datetime_fields",
+    "format_size",
+    "handle_resource_export",
+    "output_list",
+    "output_result",
+    "parse_json_line",
+    "resolve_resource",
+    "handle_ambiguous_resource",
+    "sdk_version",
+]

glaip_sdk/cli/core/context.py

@@ -0,0 +1,124 @@
+"""CLI context helpers, config loading, and credential resolution.
+
+Authors:
+    Raymond Christopher (raymond.christopher@gdplabs.id)
+    Putu Ravindra Wiguna (putu.r.wiguna@gdplabs.id)
+"""
+
+from __future__ import annotations
+
+import importlib
+import os
+from collections.abc import Mapping
+from contextlib import contextmanager
+from typing import TYPE_CHECKING, Any, cast
+
+import click
+
+from glaip_sdk.cli.config import load_config
+from glaip_sdk.cli.hints import command_hint
+
+if TYPE_CHECKING:  # pragma: no cover - import-only during type checking
+    from glaip_sdk import Client
+
+
+@contextmanager
+def bind_slash_session_context(ctx: Any, session: Any) -> Any:
+    """Temporarily attach a slash session to the Click context.
+
+    Args:
+        ctx: Click context object.
+        session: SlashSession instance to bind.
+
+    Yields:
+        None - context manager for use in with statement.
+    """
+    ctx_obj = getattr(ctx, "obj", None)
+    has_context = isinstance(ctx_obj, dict)
+    previous_session = ctx_obj.get("_slash_session") if has_context else None
+    if has_context:
+        ctx_obj["_slash_session"] = session
+    try:
+        yield
+    finally:
+        if has_context:
+            if previous_session is None:
+                ctx_obj.pop("_slash_session", None)
+            else:
+                ctx_obj["_slash_session"] = previous_session
+
+
+def restore_slash_session_context(ctx_obj: dict[str, Any], previous_session: Any | None) -> None:
+    """Restore slash session context after operation.
+
+    Args:
+        ctx_obj: Click context obj dictionary.
+        previous_session: Previous session to restore, or None to remove.
+    """
+    if previous_session is None:
+        ctx_obj.pop("_slash_session", None)
+    else:
+        ctx_obj["_slash_session"] = previous_session
+
+
+def handle_best_effort_check(
+    check_func: Any,
+) -> None:
+    """Handle best-effort duplicate/existence checks with proper exception handling.
+
+    Args:
+        check_func: Function that performs the check and raises ClickException if duplicate found.
+    """
+    try:
+        check_func()
+    except click.ClickException:
+        raise
+    except Exception:
+        # Non-fatal: best-effort duplicate check
+        pass
+
+
+def get_client(ctx: Any) -> Client:  # pragma: no cover
+    """Get configured client from context and account store (ctx > account)."""
+    # Import here to avoid circular import
+    from glaip_sdk.cli.auth import resolve_credentials  # noqa: PLC0415
+
+    module = importlib.import_module("glaip_sdk")
+    client_class = cast("type[Client]", module.Client)
+    context_config_obj = getattr(ctx, "obj", None)
+    context_config = context_config_obj if isinstance(context_config_obj, Mapping) else {}
+
+    account_name = context_config.get("account_name")
+    api_url, api_key, _ = resolve_credentials(
+        account_name=account_name,
+        api_url=context_config.get("api_url"),
+        api_key=context_config.get("api_key"),
+    )
+
+    if not api_url or not api_key:
+        configure_hint = command_hint("accounts add", slash_command="login", ctx=ctx)
+        actions: list[str] = []
+        if configure_hint:
+            actions.append(f"Run `{configure_hint}` to add an account profile")
+        else:
+            actions.append("add an account with 'aip accounts add'")
+        raise click.ClickException(f"Missing api_url/api_key. {' or '.join(actions)}.")
+
+    # Get timeout from context or config
+    timeout = context_config.get("timeout")
+    if timeout is None:
+        raw_timeout = os.getenv("AIP_TIMEOUT", "0") or "0"
+        try:
+            timeout = float(raw_timeout) if raw_timeout != "0" else None
+        except ValueError:
+            timeout = None
+    if timeout is None:
+        # Fallback to legacy config
+        file_config = load_config() or {}
+        timeout = file_config.get("timeout")
+
+    return client_class(
+        api_url=api_url,
+        api_key=api_key,
+        timeout=float(timeout or 30.0),
+    )