glaip-sdk 0.7.6__py3-none-any.whl → 0.7.8__py3-none-any.whl

glaip_sdk/cli/account_store.py

@@ -523,6 +523,21 @@ class AccountStore:
 
         self._save_config(config)
 
+    def save_config_updates(self, config: dict[str, Any]) -> None:
+        """Save config updates, preserving all existing keys.
+
+        This method allows external code to update arbitrary config keys
+        (e.g., TUI preferences) while preserving the full config structure.
+
+        Args:
+            config: Complete configuration dictionary to save. This should
+                include all keys that should be preserved, not just updates.
+
+        Raises:
+            AccountStoreError: If config file cannot be written.
+        """
+        self._save_config(config)
+
 
 # Global instance for convenience
 _account_store = AccountStore()

glaip_sdk/cli/config.py

@@ -47,6 +47,7 @@ _PRESERVE_KEYS = {
     "version",
     "active_account",
     "accounts",
+    "tui",
 }
 
 

glaip_sdk/cli/slash/tui/accounts_app.py

@@ -3,6 +3,11 @@
 Provides a minimal interactive list with the same columns/order as the Rich
 fallback (name, API URL, masked key, status) and keyboard navigation.
 
+Integrates with TUI foundation services:
+- KeybindRegistry: Centralized keybind registration with scoped actions
+- ClipboardAdapter: Cross-platform clipboard operations with OSC 52 support
+- ToastBus: Non-blocking toast notifications for user feedback
+
 Authors:
     Raymond Christopher (raymond.christopher@gdplabs.id)
 """
@@ -23,10 +28,13 @@ from glaip_sdk.cli.slash.accounts_shared import (
     env_credentials_present,
 )
 from glaip_sdk.cli.slash.tui.background_tasks import BackgroundTaskMixin
-from glaip_sdk.cli.slash.tui.clipboard import ClipboardAdapter
+from glaip_sdk.cli.slash.tui.clipboard import ClipboardAdapter, ClipboardResult
 from glaip_sdk.cli.slash.tui.context import TUIContext
+from glaip_sdk.cli.slash.tui.keybind_registry import KeybindRegistry
 from glaip_sdk.cli.slash.tui.loading import hide_loading_indicator, show_loading_indicator
+from glaip_sdk.cli.slash.tui.terminal import TerminalCapabilities
 from glaip_sdk.cli.slash.tui.theme.catalog import _BUILTIN_THEMES
+from glaip_sdk.cli.slash.tui.toast import ToastBus
 from glaip_sdk.cli.validators import validate_api_key
 from glaip_sdk.utils.validation import validate_url
 
@@ -84,6 +92,30 @@ FORM_KEY_ID = "#form-key"
 # CSS file name
 CSS_FILE_NAME = "accounts.tcss"
 
+KEYBIND_SCOPE = "accounts"
+KEYBIND_CATEGORY = "Accounts"
+
+
+@dataclass
+class KeybindDef:
+    """Keybind definition with action, key, and description."""
+
+    action: str
+    key: str
+    description: str
+
+
+KEYBIND_DEFINITIONS: tuple[KeybindDef, ...] = (
+    KeybindDef("switch_row", "enter", "Switch"),
+    KeybindDef("focus_filter", "/", "Filter"),
+    KeybindDef("add_account", "a", "Add"),
+    KeybindDef("edit_account", "e", "Edit"),
+    KeybindDef("delete_account", "d", "Delete"),
+    KeybindDef("copy_account", "c", "Copy"),
+    KeybindDef("clear_or_exit", "escape", "Close"),
+    KeybindDef("app_exit", "q", "Close"),
+)
+
 
 @dataclass
 class AccountsTUICallbacks:
@@ -250,6 +282,27 @@ class AccountFormModal(_AccountFormBase):  # pragma: no cover - interactive
         self._connection_tester = connection_tester
         self._validate_name = validate_name
 
+    def _get_api_url_suggestions(self, _value: str) -> list[str]:
+        """Get API URL suggestions from existing accounts.
+
+        Args:
+            _value: Current input value (unused, but required by Textual's suggestor API).
+
+        Returns:
+            List of unique API URLs from existing accounts.
+        """
+        try:
+            store = get_account_store()
+            accounts = store.list_accounts()
+            # Extract unique API URLs, excluding the current account's URL in edit mode
+            existing_url = self._existing.get("api_url", "")
+            urls = {account.get("api_url", "") for account in accounts.values() if account.get("api_url")}
+            if existing_url in urls:
+                urls.remove(existing_url)
+            return sorted(urls)
+        except Exception:  # pragma: no cover - defensive
+            return []
+
     def compose(self) -> ComposeResult:
         """Render the form controls."""
         title = "Add account" if self._mode == "add" else "Edit account"
@@ -259,7 +312,12 @@ class AccountFormModal(_AccountFormBase):  # pragma: no cover - interactive
             id="form-name",
             disabled=self._mode == "edit",
         )
-        url_input = Input(value=self._existing.get("api_url", ""), placeholder="https://api.example.com", id="form-url")
+        url_input = Input(
+            value=self._existing.get("api_url", ""),
+            placeholder="https://api.example.com",
+            id="form-url",
+            suggestions=self._get_api_url_suggestions,
+        )
         key_input = Input(value="", placeholder="sk-...", password=True, id="form-key")
         test_checkbox = Checkbox(
             "Test connection before save",
@@ -427,8 +485,13 @@ class AccountsTextualApp(BackgroundTaskMixin, _AppBase):  # pragma: no cover - i
         self._env_lock = env_lock
         self._callbacks = callbacks
         self._ctx = ctx
+        self._keybinds: KeybindRegistry | None = None
+        self._toast_bus: ToastBus | None = None
+        self._toast_ready = False
+        self._clipboard: ClipboardAdapter | None = None
         self._filter_text: str = ""
         self._is_switching = False
+        self._initialize_context_services()
 
     def compose(self) -> ComposeResult:
         """Build the Textual layout."""
@@ -481,6 +544,52 @@ class AccountsTextualApp(BackgroundTaskMixin, _AppBase):  # pragma: no cover - i
         main = self.query_one(Vertical)
         main.styles.gap = 0
         self._update_filter_button_visibility()
+        self._prepare_toasts()
+        self._register_keybinds()
+
+    def _initialize_context_services(self) -> None:
+        if self._ctx:
+            if self._ctx.keybinds is None:
+                self._ctx.keybinds = KeybindRegistry()
+            if self._ctx.toasts is None:
+                self._ctx.toasts = ToastBus()
+            if self._ctx.clipboard is None:
+                self._ctx.clipboard = ClipboardAdapter(terminal=self._ctx.terminal)
+            self._keybinds = self._ctx.keybinds
+            self._toast_bus = self._ctx.toasts
+            self._clipboard = self._ctx.clipboard
+        else:
+            # Fallback: create services independently when ctx is None
+            terminal = TerminalCapabilities(
+                tty=True, ansi=True, osc52=False, osc11_bg=None, mouse=False, truecolor=False
+            )
+            self._clipboard = ClipboardAdapter(terminal=terminal)
+
+    def _prepare_toasts(self) -> None:
+        """Prepare toast system by marking ready and clearing any existing toasts."""
+        self._toast_ready = True
+        if self._toast_bus:
+            self._toast_bus.clear()
+
+    def _register_keybinds(self) -> None:
+        if not self._keybinds:
+            return
+        for keybind_def in KEYBIND_DEFINITIONS:
+            scoped_action = f"{KEYBIND_SCOPE}.{keybind_def.action}"
+            if self._keybinds.get(scoped_action):
+                continue
+            try:
+                self._keybinds.register(
+                    action=scoped_action,
+                    key=keybind_def.key,
+                    description=keybind_def.description,
+                    category=KEYBIND_CATEGORY,
+                )
+            except ValueError as e:
+                # Expected: duplicate registration (already registered by another component)
+                # Silently skip to allow multiple apps to register same keybinds
+                logging.debug(f"Skipping duplicate keybind registration: {scoped_action}", exc_info=e)
+                continue
 
     def _header_text(self) -> str:
         """Build header text with active account and host."""
@@ -643,6 +752,24 @@ class AccountsTextualApp(BackgroundTaskMixin, _AppBase):  # pragma: no cover - i
         """Hide the loading indicator."""
         hide_loading_indicator(self, ACCOUNTS_LOADING_ID)
 
+    def _handle_switch_scheduling_error(self, exc: Exception) -> None:
+        """Handle errors when scheduling the switch task fails.
+
+        Args:
+            exc: The exception that occurred during task scheduling.
+        """
+        self._hide_loading()
+        self._is_switching = False
+        error_msg = f"Switch failed to start: {exc}"
+        if self._toast_ready and self._toast_bus:
+            self._toast_bus.show(message=error_msg, variant="error")
+        try:
+            self._set_status(error_msg, "red")
+        except Exception:
+            # App not mounted yet, status update not possible
+            logging.error(error_msg, exc_info=exc)
+        logging.getLogger(__name__).debug("Failed to schedule switch task", exc_info=exc)
+
     def _clear_filter(self) -> None:
         """Clear the filter input and reset filter state."""
         filter_input = self.query_one(FILTER_INPUT_ID, Input)
@@ -665,7 +792,9 @@ class AccountsTextualApp(BackgroundTaskMixin, _AppBase):  # pragma: no cover - i
 
             if switched:
                 self._active_account = name
-                self._set_status(message or f"Switched to '{name}'.", "green")
+                status_msg = message or f"Switched to '{name}'."
+                if self._toast_ready and self._toast_bus:
+                    self._toast_bus.show(message=status_msg, variant="success")
                 self._update_header()
                 self._reload_rows()
             else:
@@ -674,11 +803,7 @@ class AccountsTextualApp(BackgroundTaskMixin, _AppBase):  # pragma: no cover - i
         try:
             self.track_task(perform(), logger=logging.getLogger(__name__))
         except Exception as exc:
-            # If scheduling the task fails, clear loading/switching state and surface the error.
-            self._hide_loading()
-            self._is_switching = False
-            self._set_status(f"Switch failed to start: {exc}", "red")
-            logging.getLogger(__name__).debug("Failed to schedule switch task", exc_info=exc)
+            self._handle_switch_scheduling_error(exc)
 
     def _update_header(self) -> None:
         """Refresh header text to reflect active/lock state."""
@@ -781,12 +906,32 @@ class AccountsTextualApp(BackgroundTaskMixin, _AppBase):  # pragma: no cover - i
             return
 
         text = f"Account: {name}\nURL: {account.get('api_url', '')}"
-        adapter = ClipboardAdapter()
-        result = adapter.copy(text)
+        adapter = self._clipboard or ClipboardAdapter(terminal=self._ctx.terminal if self._ctx else None)
+        # OSC 52 works by writing to stdout, no custom writer needed
+        try:
+            asyncio.get_running_loop()
+        except RuntimeError:
+            result = adapter.copy(text)
+            self._handle_copy_result(name, result)
+            return
+
+        async def perform() -> None:
+            result = await asyncio.to_thread(adapter.copy, text)
+            self._handle_copy_result(name, result)
+
+        self.track_task(perform(), logger=logging.getLogger(__name__))
 
+    def _handle_copy_result(self, name: str, result: ClipboardResult) -> None:
+        """Update UI state after a copy attempt."""
         if result.success:
+            if self._toast_ready and self._toast_bus:
+                self._toast_bus.copy_success(label=name)
+            # Status fallback until toast widget is implemented (see specs/workflow/tui-toast-system/spec.md Phase 2)
             self._set_status(f"Copied '{name}' to clipboard.", "green")
         else:
+            if self._toast_ready and self._toast_bus:
+                self._toast_bus.show(message=f"Copy failed: {result.message}", variant="warning")
+            # Status fallback until toast widget is implemented (see specs/workflow/tui-toast-system/spec.md Phase 2)
             self._set_status(f"Copy failed: {result.message}", "red")
 
     def _check_env_lock_hotkey(self) -> bool:

glaip_sdk/cli/slash/tui/context.py

@@ -12,13 +12,14 @@ from __future__ import annotations
 
 import os
 from dataclasses import dataclass
-from typing import TYPE_CHECKING
 
+from glaip_sdk.cli.account_store import get_account_store
+from glaip_sdk.cli.slash.tui.clipboard import ClipboardAdapter
+from glaip_sdk.cli.slash.tui.keybind_registry import KeybindRegistry
 from glaip_sdk.cli.slash.tui.terminal import TerminalCapabilities
 from glaip_sdk.cli.slash.tui.theme import ThemeManager
-
-if TYPE_CHECKING:
-    from glaip_sdk.cli.slash.tui.toast import ToastBus
+from glaip_sdk.cli.slash.tui.toast import ToastBus
+from glaip_sdk.cli.tui_settings import load_tui_settings
 
 
 @dataclass
@@ -37,23 +38,47 @@ class TUIContext:
     """
 
     terminal: TerminalCapabilities
-    keybinds: object | None = None
+    keybinds: KeybindRegistry | None = None
     theme: ThemeManager | None = None
     toasts: ToastBus | None = None
-    clipboard: object | None = None
+    clipboard: ClipboardAdapter | None = None
 
     @classmethod
     async def create(cls) -> TUIContext:
         """Create a TUIContext instance with detected terminal capabilities.
 
         This factory method detects terminal capabilities asynchronously and
-        returns a populated TUIContext instance. Other components (keybinds,
-        theme, toasts, clipboard) will be set incrementally as they are created.
+        returns a populated TUIContext instance with all services initialized
+        (keybinds, theme, toasts, clipboard).
 
         Returns:
-            TUIContext instance with terminal capabilities detected.
+            TUIContext instance with all services initialized.
         """
         terminal = await TerminalCapabilities.detect()
-        theme_name = os.getenv("AIP_TUI_THEME") or None
-        theme = ThemeManager(terminal, theme=theme_name)
-        return cls(terminal=terminal, theme=theme)
+        store = get_account_store()
+        settings = load_tui_settings(store=store)
+
+        # Handle env var override: normalize empty strings and "default" to None
+        # Empty string from os.getenv() is falsy, so strip() result becomes None in the or expression
+        env_theme = os.getenv("AIP_TUI_THEME")
+        env_theme = env_theme.strip() if env_theme else None
+        if env_theme and env_theme.lower() == "default":
+            env_theme = None
+
+        theme_name = env_theme or settings.theme_name
+        theme = ThemeManager(
+            terminal,
+            mode=settings.theme_mode,
+            theme=theme_name,
+            settings_store=store,
+        )
+        keybinds = KeybindRegistry()
+        toasts = ToastBus()
+        clipboard = ClipboardAdapter(terminal=terminal)
+        return cls(
+            terminal=terminal,
+            keybinds=keybinds,
+            theme=theme,
+            toasts=toasts,
+            clipboard=clipboard,
+        )

glaip_sdk/cli/slash/tui/theme/manager.py

@@ -6,9 +6,11 @@ import logging
 from enum import Enum
 from typing import Literal
 
+from glaip_sdk.cli.account_store import AccountStore, AccountStoreError
 from glaip_sdk.cli.slash.tui.terminal import TerminalCapabilities
 from glaip_sdk.cli.slash.tui.theme.catalog import default_theme_name_for_mode, get_builtin_theme
 from glaip_sdk.cli.slash.tui.theme.tokens import ThemeTokens
+from glaip_sdk.cli.tui_settings import persist_tui_theme
 
 logger = logging.getLogger(__name__)
 
@@ -30,11 +32,13 @@ class ThemeManager:
         *,
         mode: ThemeMode | str = ThemeMode.AUTO,
         theme: str | None = None,
+        settings_store: AccountStore | None = None,
     ) -> None:
         """Initialize the theme manager."""
         self._terminal = terminal
         self._mode = self._coerce_mode(mode)
-        self._theme = theme
+        self._theme = self._normalize_theme_name(theme)
+        self._settings_store = settings_store
 
     @property
     def mode(self) -> ThemeMode:
@@ -70,10 +74,12 @@ class ThemeManager:
     def set_mode(self, mode: ThemeMode | str) -> None:
         """Set auto/light/dark mode."""
         self._mode = self._coerce_mode(mode)
+        self._persist_preferences()
 
     def set_theme(self, theme: str | None) -> None:
         """Set explicit theme name (or None to use the default)."""
-        self._theme = theme
+        self._theme = self._normalize_theme_name(theme)
+        self._persist_preferences()
 
     def _coerce_mode(self, mode: ThemeMode | str) -> ThemeMode:
         """Coerce a mode value to ThemeMode enum, defaulting to AUTO on invalid input."""
@@ -84,3 +90,23 @@ class ThemeManager:
         except ValueError:
             logger.warning(f"Invalid theme mode '{mode}', defaulting to AUTO")
             return ThemeMode.AUTO
+
+    def _persist_preferences(self) -> None:
+        if self._settings_store is None:
+            return
+        try:
+            persist_tui_theme(mode=self._mode.value, name=self._theme, store=self._settings_store)
+        except (OSError, AccountStoreError) as exc:
+            # Log recoverable errors (permissions, I/O) as warnings
+            logger.warning(f"Failed to persist TUI theme preferences: {exc}")
+        except Exception as exc:
+            # Log unexpected errors at error level for debugging
+            logger.error(f"Unexpected error persisting TUI theme preferences: {exc}", exc_info=True)
+
+    def _normalize_theme_name(self, theme: str | None) -> str | None:
+        if not isinstance(theme, str):
+            return None
+        cleaned = theme.strip()
+        if not cleaned or cleaned.lower() == "default":
+            return None
+        return cleaned

glaip_sdk/cli/tui_settings.py

@@ -0,0 +1,125 @@
+"""Typed loader/saver for TUI preferences stored in config.yaml.
+
+This module implements the TUI preferences store as defined in
+`specs/architecture/tui-preferences-store/spec.md`.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Literal, cast
+
+from glaip_sdk.cli.account_store import AccountStore, get_account_store
+
+ThemeModeValue = Literal["auto", "light", "dark"]
+
+_DEFAULT_THEME_MODE: ThemeModeValue = "auto"
+_DEFAULT_LEADER = "ctrl+x"
+_DEFAULT_MOUSE_CAPTURE = False
+
+
+@dataclass(frozen=True)
+class TUISettings:
+    """Resolved TUI preferences from config.yaml."""
+
+    theme_mode: ThemeModeValue = _DEFAULT_THEME_MODE
+    theme_name: str | None = None
+    leader: str = _DEFAULT_LEADER
+    keybind_overrides: dict[str, str] = field(default_factory=dict)
+    mouse_capture: bool = _DEFAULT_MOUSE_CAPTURE
+
+
+def load_tui_settings(*, store: AccountStore | None = None) -> TUISettings:
+    """Load TUI preferences from the CLI config file."""
+    store = store or get_account_store()
+    config = store.load_config()
+
+    tui = _as_dict(config.get("tui"))
+    theme = _as_dict(tui.get("theme"))
+    mode = _coerce_theme_mode(theme.get("mode"))
+    name = _normalize_theme_name(theme.get("name"))
+
+    keybinds = _as_dict(tui.get("keybinds"))
+    leader = keybinds.get("leader")
+    if not isinstance(leader, str) or not leader.strip():
+        leader = _DEFAULT_LEADER
+
+    overrides = _coerce_keybind_overrides(keybinds.get("overrides"))
+
+    mouse_capture = tui.get("mouse_capture")
+    if not isinstance(mouse_capture, bool):
+        mouse_capture = _DEFAULT_MOUSE_CAPTURE
+
+    return TUISettings(
+        theme_mode=mode,
+        theme_name=name,
+        leader=leader,
+        keybind_overrides=overrides,
+        mouse_capture=mouse_capture,
+    )
+
+
+def update_tui_settings(patch: dict[str, Any], *, store: AccountStore | None = None) -> None:
+    """Update TUI preferences, preserving unrelated config keys."""
+    store = store or get_account_store()
+    config = store.load_config()
+
+    existing = _as_dict(config.get("tui"))
+    config["tui"] = _merge_dict(existing, patch)
+
+    store.save_config_updates(config)
+
+
+def persist_tui_theme(*, mode: ThemeModeValue, name: str | None, store: AccountStore | None = None) -> None:
+    """Persist theme preferences in the tui.theme namespace."""
+    update_tui_settings(
+        {"theme": {"mode": _coerce_theme_mode(mode), "name": _serialize_theme_name(name)}},
+        store=store,
+    )
+
+
+def _as_dict(value: Any) -> dict[str, Any]:
+    if isinstance(value, dict):
+        return dict(value)
+    return {}
+
+
+def _coerce_theme_mode(value: Any) -> ThemeModeValue:
+    if isinstance(value, str):
+        lowered = value.strip().lower()
+        if lowered in {"auto", "light", "dark"}:
+            return cast(ThemeModeValue, lowered)
+    return _DEFAULT_THEME_MODE
+
+
+def _normalize_theme_name(value: Any) -> str | None:
+    if not isinstance(value, str):
+        return None
+    cleaned = value.strip()
+    if not cleaned or cleaned.lower() == "default":
+        return None
+    return cleaned
+
+
+def _serialize_theme_name(name: str | None) -> str:
+    if isinstance(name, str):
+        cleaned = name.strip()
+        if cleaned:
+            return cleaned
+    return "default"
+
+
+def _coerce_keybind_overrides(value: Any) -> dict[str, str]:
+    if not isinstance(value, dict):
+        return {}
+    return {key: val for key, val in value.items() if isinstance(key, str) and isinstance(val, str)}
+
+
+def _merge_dict(base: dict[str, Any], patch: dict[str, Any]) -> dict[str, Any]:
+    merged = dict(base)
+    for key, value in patch.items():
+        if isinstance(value, dict) and isinstance(merged.get(key), dict):
+            merged[key] = _merge_dict(cast(dict[str, Any], merged[key]), value)
+        else:
+            merged[key] = value
+    return merged

glaip_sdk/registry/tool.py

@@ -1,6 +1,6 @@
 """Tool registry for glaip_sdk.
 
-This module provides the ToolRegistry that caches deployed tools
+This module provides a ToolRegistry that caches deployed tools
 to avoid redundant API calls when deploying agents with tools.
 
 Authors:
@@ -92,7 +92,7 @@ class ToolRegistry(BaseRegistry["Tool"]):
         Raises:
             ValueError: If name cannot be extracted from the reference.
         """
-        # Lazy import to avoid circular dependency
+        # Lazy import to avoid circular dependency: Tool -> ToolRegistry -> Tool
         from glaip_sdk.tools.base import Tool  # noqa: PLC0415
 
         if isinstance(ref, str):
@@ -129,6 +129,34 @@ class ToolRegistry(BaseRegistry["Tool"]):
         if hasattr(tool, "id") and tool.id:
             self._cache[tool.id] = tool
 
+    def _resolve_native_platform_tool(self, name: str, tool_class: type | None = None) -> Tool:
+        """Find a native tool on the platform and cache it.
+
+        Args:
+            name: The tool name to look up.
+            tool_class: Optional local implementation to preserve.
+
+        Returns:
+            The resolved Tool object.
+
+        Raises:
+            ValueError: If the tool is not found on the platform.
+        """
+        from glaip_sdk.utils.discovery import find_tool  # noqa: PLC0415
+
+        logger.info("Looking up native tool: %s", name)
+        tool = find_tool(name)
+        if tool:
+            # Preserve local implementation if provided
+            if tool_class:
+                tool.tool_class = tool_class
+            self._cache_tool(tool, name)
+            return tool
+
+        raise ValueError(
+            f"Native tool '{name}' not found on platform. Ensure the tool is deployed or check for name mismatches."
+        )
+
     def _resolve_tool_instance(self, ref: Any, name: str) -> Tool | None:
         """Resolve a ToolClass instance.
 
@@ -139,11 +167,9 @@ class ToolRegistry(BaseRegistry["Tool"]):
         Returns:
             The resolved tool, or None if not a ToolClass instance.
         """
-        # Lazy imports to avoid circular dependency
+        # Lazy imports to avoid circular dependency: Tool -> ToolRegistry -> Tool
         from glaip_sdk.tools.base import Tool as ToolClass  # noqa: PLC0415
         from glaip_sdk.tools.base import ToolType  # noqa: PLC0415
-        from glaip_sdk.utils.discovery import find_tool  # noqa: PLC0415
-        from glaip_sdk.utils.sync import update_or_create_tool  # noqa: PLC0415
 
         # Use try/except to handle mocked Tool class in tests
         try:
@@ -162,19 +188,11 @@ class ToolRegistry(BaseRegistry["Tool"]):
 
         # Tool.from_native() - look up on platform
         if ref.tool_type == ToolType.NATIVE:
-            logger.info("Looking up native tool: %s", name)
-            tool = find_tool(name)
-            if tool:
-                self._cache[name] = tool
-                return tool
-            raise ValueError(f"Native tool not found on platform: {name}")
-
-        # Tool.from_langchain() - upload the tool_class
+            return self._resolve_native_platform_tool(name, tool_class=getattr(ref, "tool_class", None))
+
+        # Tool.from_langchain() - resolve the inner tool_class (promoted or uploaded)
         if ref.tool_class is not None:
-            logger.info("Uploading custom tool: %s", name)
-            tool = update_or_create_tool(ref.tool_class)
-            self._cache_tool(tool, name)
-            return tool
+            return self._resolve_custom_tool(ref.tool_class, name)
 
         # Unresolvable Tool instance - neither native nor has tool_class
         raise ValueError(
@@ -193,8 +211,6 @@ class ToolRegistry(BaseRegistry["Tool"]):
         Returns:
             The resolved tool, or None if not a deployed tool.
         """
-        from glaip_sdk.utils.discovery import find_tool  # noqa: PLC0415
-
         # Already deployed tool (not a ToolClass, but has id/name)
         # This handles API response objects and backward compatibility
         if not (hasattr(ref, "id") and hasattr(ref, "name") and not isinstance(ref, type)):
@@ -207,32 +223,50 @@ class ToolRegistry(BaseRegistry["Tool"]):
             return ref
 
         # Tool without ID (backward compatibility) - look up on platform
-        logger.info("Looking up native tool: %s", name)
-        tool = find_tool(name)
-        if tool:
-            # Use _cache_tool to cache by both name and ID if available
-            self._cache_tool(tool, name)
-            return tool
-        raise ValueError(f"Native tool not found on platform: {name}")
+        return self._resolve_native_platform_tool(name)
 
     def _resolve_custom_tool(self, ref: Any, name: str) -> Tool | None:
-        """Resolve a custom tool class.
+        """Resolve a custom tool class, promoting aip_agents.tools classes to NATIVE.
+
+        This method handles two main paths:
+        1. **Promotion**: If the tool class is from `aip_agents.tools`, it is automatically
+           promoted to a `NATIVE` tool type. It then performs a platform lookup to link it
+           with the deployed native tool while preserving the local `tool_class` for local execution.
+        2. **Upload**: If it is a standard LangChain tool, it is uploaded to the platform
+           as a custom tool.
 
         Args:
-            ref: The tool reference to resolve.
+            ref: The tool reference (usually a class) to resolve.
             name: The extracted tool name.
 
         Returns:
             The resolved tool, or None if not a custom tool.
         """
-        from glaip_sdk.utils.sync import update_or_create_tool  # noqa: PLC0415
+        # aip_agents tools are automatically promoted to NATIVE
+        if self._is_aip_agents_tool(ref):
+            from glaip_sdk.utils.tool_detection import get_tool_name  # noqa: PLC0415
+
+            # Get name from class attribute or field
+            tool_name = get_tool_name(ref)
+            if tool_name is None:
+                raise ValueError(f"Tool class {ref.__name__} has no 'name' attribute")
+
+            return self._resolve_native_platform_tool(tool_name, tool_class=ref)
 
         if not self._is_custom_tool(ref):
             return None
 
+        # Regular custom tools - upload to platform
+        from glaip_sdk.utils.sync import update_or_create_tool  # noqa: PLC0415
+
         logger.info("Uploading custom tool: %s", name)
         tool = update_or_create_tool(ref)
+
+        # Cache the resolved tool
         self._cache_tool(tool, name)
+        if hasattr(tool, "id") and tool.id:
+            self._cache[tool.id] = tool
+
         return tool
 
     def _resolve_dict_tool(self, ref: Any, name: str) -> Tool | None:
@@ -245,6 +279,7 @@ class ToolRegistry(BaseRegistry["Tool"]):
         Returns:
             The resolved tool, or None if not a dict.
         """
+        # Lazy imports to avoid circular dependency
         from glaip_sdk.tools.base import Tool as ToolClass  # noqa: PLC0415
 
         if not isinstance(ref, dict):
@@ -268,18 +303,10 @@ class ToolRegistry(BaseRegistry["Tool"]):
         Returns:
             The resolved tool, or None if not a string.
         """
-        from glaip_sdk.utils.discovery import find_tool  # noqa: PLC0415
-
         if not isinstance(ref, str):
             return None
 
-        logger.info("Looking up tool by name: %s", name)
-        tool = find_tool(name)
-        if tool:
-            # Use _cache_tool to cache by both name and ID for consistency
-            self._cache_tool(tool, name)
-            return tool
-        raise ValueError(f"Tool not found on platform: {name}")
+        return self._resolve_native_platform_tool(name)
 
     def _resolve_and_cache(self, ref: Any, name: str) -> Tool:
         """Resolve tool reference - upload if class, find if string/native.
@@ -292,7 +319,7 @@ class ToolRegistry(BaseRegistry["Tool"]):
             The resolved glaip_sdk.models.Tool object.
 
         Raises:
-            ValueError: If the tool cannot be resolved.
+            ValueError: If tool cannot be resolved.
         """
         # Try each resolution strategy in order
         resolvers = [
@@ -310,6 +337,24 @@ class ToolRegistry(BaseRegistry["Tool"]):
 
         raise ValueError(f"Could not resolve tool reference: {ref}")
 
+    def _is_aip_agents_tool(self, ref: Any) -> bool:
+        """Check if reference is an aip-agents tool.
+
+        Args:
+            ref: The reference to check.
+
+        Returns:
+            True if ref is from aip_agents.tools package.
+        """
+        try:
+            from glaip_sdk.utils.tool_detection import (  # noqa: PLC0415
+                is_aip_agents_tool,
+            )
+        except ImportError:
+            return False
+
+        return is_aip_agents_tool(ref)
+
     def _is_custom_tool(self, ref: Any) -> bool:
         """Check if reference is a custom tool class/instance.
 
@@ -323,10 +368,18 @@ class ToolRegistry(BaseRegistry["Tool"]):
             from glaip_sdk.utils.tool_detection import (  # noqa: PLC0415
                 is_langchain_tool,
             )
+
+            is_tool = is_langchain_tool(ref)
         except ImportError:
+            is_tool = hasattr(ref, "args_schema") or hasattr(ref, "_run")
+            if is_tool:
+                logger.warning("tool_detection module missing; identifying tool via fallback attributes.")
+
+        # aip_agents tools are NOT custom - they're native
+        if is_tool and self._is_aip_agents_tool(ref):
             return False
 
-        return is_langchain_tool(ref)
+        return is_tool
 
     def resolve(self, ref: Any) -> Tool:
         """Resolve a tool reference to a platform Tool object.
@@ -348,7 +401,6 @@ class ToolRegistry(BaseRegistry["Tool"]):
                     # Use _cache_tool to cache by both name and ID for consistency
                     self._cache_tool(ref, name)
                 return ref
-
             # Tool without ID (e.g., from Tool.from_native()) - needs platform lookup
             # Fall through to normal resolution
 

glaip_sdk/runner/tool_adapter/langchain_tool_adapter.py

@@ -9,9 +9,10 @@ Authors:
 
 from typing import Any
 
-from glaip_sdk.runner.tool_adapter.base_tool_adapter import BaseToolAdapter
 from gllm_core.utils import LoggerManager
 
+from glaip_sdk.runner.tool_adapter.base_tool_adapter import BaseToolAdapter
+
 logger = LoggerManager().get_logger(__name__)
 
 # Constant for unknown tool name placeholder
@@ -73,8 +74,30 @@ class LangChainToolAdapter(BaseToolAdapter):
         if self._is_langchain_tool(tool_ref):
             return self._instantiate_langchain_tool(tool_ref)
 
-        # 3. Platform tools (not supported)
+        # 3. Native tools with discovered class
         if self._is_platform_tool(tool_ref):
+            # Try to discover local implementation for native tool
+            from glaip_sdk.utils.tool_detection import (  # noqa: PLC0415
+                find_aip_agents_tool_class,
+                get_tool_name,
+            )
+
+            # Get tool name from reference
+            tool_name = get_tool_name(tool_ref) if not isinstance(tool_ref, str) else tool_ref
+
+            if tool_name:
+                discovered_class = find_aip_agents_tool_class(tool_name)
+                if discovered_class:
+                    logger.info("Instantiating native tool locally: %s", tool_name)
+                    try:
+                        return discovered_class()
+                    except TypeError as exc:
+                        raise ValueError(
+                            f"Could not instantiate native tool '{tool_name}'. "
+                            "Ensure it has a zero-argument constructor or adjust the instantiation logic."
+                        ) from exc
+
+            # If no local class found, raise platform tool error
             raise ValueError(self._get_platform_tool_error(tool_ref))
 
         # 4. Unknown type

glaip_sdk/tools/base.py

@@ -231,6 +231,9 @@ class Tool:
         Native tools are pre-existing tools on the GL AIP platform
         that don't require uploading (e.g., "time_tool", "web_search").
 
+        For local execution, automatically discovers the corresponding aip_agents.tools
+        class if available. If not found, tool can only be used after deployment.
+
         Args:
             name: The name of the native tool on the platform.
 
@@ -241,7 +244,14 @@ class Tool:
             >>> time_tool = Tool.from_native("time_tool")
             >>> web_search = Tool.from_native("web_search")
         """
-        return cls(name=name, type=ToolType.NATIVE)
+        # Try to discover local implementation for native execution
+        from glaip_sdk.utils.tool_detection import (  # noqa: PLC0415
+            find_aip_agents_tool_class,
+        )
+
+        tool_class = find_aip_agents_tool_class(name)
+
+        return cls(name=name, type=ToolType.NATIVE, tool_class=tool_class)
 
     @classmethod
     def from_langchain(cls, tool_class: type) -> Tool:
@@ -287,19 +297,11 @@ class Tool:
         Raises:
             ValueError: If name cannot be extracted or is not a valid string.
         """
-        # Try model_fields first (Pydantic v2)
-        if hasattr(tool_class, "model_fields"):
-            name_field = tool_class.model_fields.get("name")
-            if name_field and name_field.default:
-                # Validate that default is actually a string
-                if isinstance(name_field.default, str):
-                    return name_field.default
-
-        # Try direct name attribute
-        if hasattr(tool_class, "name"):
-            name_attr = getattr(tool_class, "name")
-            if isinstance(name_attr, str):
-                return name_attr
+        from glaip_sdk.utils.tool_detection import get_tool_name  # noqa: PLC0415
+
+        name = get_tool_name(tool_class)
+        if name:
+            return name
 
         # If we can't extract the name, raise an error
         raise ValueError(
@@ -385,12 +387,22 @@ class Tool:
         if not self._client:
             raise RuntimeError(_CLIENT_NOT_AVAILABLE_MSG)
 
+        # Handle both Client (has .tools) and ToolClient (direct methods)
+        # Priority: Check if client has a 'tools' attribute (Client instance)
+        # Otherwise, use client directly (ToolClient instance)
+        if hasattr(self._client, "tools") and self._client.tools is not None:
+            # Main Client instance - use the tools sub-client
+            tools_client = self._client.tools
+        else:
+            # ToolClient instance - use directly
+            tools_client = self._client
+
         # Check if file upload is requested
         if "file" in kwargs:
             file_path = kwargs.pop("file")
-            response = self._client.tools.update_via_file(self._id, file_path, **kwargs)
+            response = tools_client.update_tool_via_file(self._id, file_path, **kwargs)
         else:
-            response = self._client.tools.update(tool_id=self._id, **kwargs)
+            response = tools_client.update_tool(tool_id=self._id, **kwargs)
 
         # Update local properties from response
         if hasattr(response, "name") and response.name:
@@ -414,7 +426,17 @@ class Tool:
         if not self._client:
             raise RuntimeError(_CLIENT_NOT_AVAILABLE_MSG)
 
-        self._client.tools.delete(tool_id=self._id)
+        # Handle both Client (has .tools) and ToolClient (direct methods)
+        # Priority: Check if client has a 'tools' attribute (Client instance)
+        # Otherwise, use client directly (ToolClient instance)
+        if hasattr(self._client, "tools") and self._client.tools is not None:
+            # Main Client instance - use the tools sub-client
+            tools_client = self._client.tools
+        else:
+            # ToolClient instance - use directly
+            tools_client = self._client
+
+        tools_client.delete_tool(self._id)
         self._id = None
         self._client = None
 

glaip_sdk/utils/__init__.py

@@ -77,6 +77,7 @@ def __getattr__(name: str) -> type:
         "get_client": _client_module,
         "set_client": _client_module,
         "reset_client": _client_module,
+        "tool_detection": "glaip_sdk.utils.tool_detection",
     }
 
     if name in lazy_imports:

glaip_sdk/utils/tool_detection.py

@@ -4,9 +4,140 @@ Authors:
     Christian Trisno Sen Long Chen (christian.t.s.l.chen@gdplabs.id)
 """
 
+from __future__ import annotations
+
 import ast
+import importlib
+import inspect
+import pkgutil
+from functools import lru_cache
 from typing import Any
 
+# Constants for frequently used strings to avoid duplication (S1192)
+_NAME = "name"
+_AIP_AGENTS_TOOLS = "aip_agents.tools"
+_BASE_TOOL = "BaseTool"
+
+# Internal map to store all discovered tools in the session
+_DISCOVERED_TOOLS: dict[str, type] | None = None
+
+
+def _should_skip_module(module_name: str) -> bool:
+    """Check if module should be skipped during tool discovery."""
+    short_name = module_name.rsplit(".", 1)[-1]
+    return short_name.startswith("_") or "test" in short_name
+
+
+def _get_pydantic_field_default(cls: type, attr_name: str, field_name: str) -> str | None:
+    """Extract default value from a Pydantic field."""
+    try:
+        fields = getattr(cls, attr_name, {})
+        field = fields.get(field_name)
+        # Broad exception handling needed because:
+        # - model_fields/__fields__ might be a descriptor that raises AttributeError
+        # - field.default might raise during access
+        # - Various Pydantic internals can raise unexpected exceptions
+        if field and hasattr(field, "default") and isinstance(field.default, str):
+            return field.default
+    except Exception:  # pylint: disable=broad-except
+        pass
+    return None
+
+
+def _get_name_from_pydantic_v2(cls: type) -> str | None:
+    """Extract name from Pydantic v2 model_fields."""
+    return _get_pydantic_field_default(cls, "model_fields", _NAME)
+
+
+def _get_name_from_pydantic_v1(cls: type) -> str | None:
+    """Extract name from Pydantic v1 __fields__."""
+    return _get_pydantic_field_default(cls, "__fields__", _NAME)
+
+
+def get_tool_name(ref: Any) -> str | None:
+    """Extract tool name from a tool class or instance.
+
+    Handles LangChain BaseTool (Pydantic v1/v2) and standard classes.
+
+    Args:
+        ref: Tool class or instance.
+
+    Returns:
+        The extracted tool name, or None if not found.
+    """
+    if ref is None:
+        return None
+
+    # 1. Try instance 'name' attribute
+    if not isinstance(ref, type):
+        try:
+            name = getattr(ref, _NAME, None)
+            if isinstance(name, str):
+                return name
+        except Exception:  # pylint: disable=broad-except
+            pass
+
+    cls = ref if isinstance(ref, type) else type(ref)
+
+    # 2. Try class 'model_fields' (Pydantic v2)
+    # Check Pydantic v2 first for forward compatibility
+    name = _get_name_from_pydantic_v2(cls)
+    if name:
+        return name
+
+    # 3. Try class '__fields__' (Pydantic v1)
+    name = _get_name_from_pydantic_v1(cls)
+    if name:
+        return name
+
+    # 4. Try direct class attribute
+    if hasattr(cls, _NAME):
+        try:
+            name_attr = getattr(cls, _NAME)
+            if isinstance(name_attr, str):
+                return name_attr
+        except Exception:  # pylint: disable=broad-except
+            pass
+
+    return None
+
+
+def _check_langchain_standard(ref: Any) -> bool:
+    """Perform standard isinstance/issubclass check for LangChain tool."""
+    try:
+        from langchain_core.tools import BaseTool  # noqa: PLC0415
+
+        # Check if BaseTool is actually a type to avoid TypeError in issubclass/isinstance
+        if isinstance(BaseTool, type):
+            if isinstance(ref, type) and issubclass(ref, BaseTool):
+                return True
+            if isinstance(ref, BaseTool):
+                return True
+    except (ImportError, TypeError):
+        pass
+    return False
+
+
+def _check_langchain_fallback(ref: Any) -> bool:
+    """Perform name-based fallback check for LangChain tool (robust for mocks).
+
+    This fallback handles cases where:
+    - BaseTool is mocked in tests
+    - BaseTool is re-imported through internal modules (e.g., runner)
+    - isinstance/issubclass checks fail due to module reloading
+    """
+    try:
+        cls = ref if isinstance(ref, type) else getattr(ref, "__class__", None)
+        if cls and hasattr(cls, "__mro__"):
+            for c in cls.__mro__:
+                c_name = getattr(c, "__name__", None)
+                c_module = getattr(c, "__module__", "")
+                if c_name == _BASE_TOOL and ("langchain" in c_module or "runner" in c_module):
+                    return True
+    except (AttributeError, TypeError):
+        pass
+    return False
+
 
 def is_langchain_tool(ref: Any) -> bool:
     """Check if ref is a LangChain BaseTool class or instance.
@@ -21,17 +152,133 @@ def is_langchain_tool(ref: Any) -> bool:
     Returns:
         True if ref is a LangChain BaseTool class or instance.
     """
+    if ref is None:
+        return False
+
+    # 1. Standard check (preferred)
+    if _check_langchain_standard(ref):
+        return True
+
+    # 2. Name-based check (robust fallback for mocks and re-imports)
+    return _check_langchain_fallback(ref)
+
+
+def is_aip_agents_tool(ref: Any) -> bool:
+    """Check if ref is an aip-agents tool class or instance.
+
+    Args:
+        ref: Object to check.
+
+    Returns:
+        True if ref is from aip_agents.tools package.
+    """
     try:
-        from langchain_core.tools import BaseTool  # noqa: PLC0415
+        # Check class module
+        if isinstance(ref, type):
+            return ref.__module__.startswith(_AIP_AGENTS_TOOLS)
+
+        # Check instance class
+        if hasattr(ref, "__class__"):
+            return ref.__class__.__module__.startswith(_AIP_AGENTS_TOOLS)
+
+        return False
+    except (AttributeError, TypeError):
+        return False
+
+
+def _get_discovered_classes_from_module(module: Any) -> list[type]:
+    """Extract BaseTool subclasses from a module."""
+    discovered_classes = []
+    for attr_name in dir(module):
+        if attr_name.startswith("_"):
+            continue
+
+        try:
+            attr = getattr(module, attr_name)
+            if inspect.isclass(attr) and is_langchain_tool(attr):
+                # Ensure it's not the BaseTool class itself
+                if getattr(attr, "__name__", None) != _BASE_TOOL:
+                    discovered_classes.append(attr)
+        except Exception:  # pylint: disable=broad-except
+            continue
+    return discovered_classes
+
+
+def _import_and_map_module(module_name: str, tools_map: dict[str, type]) -> None:
+    """Import a single module and extract its tools."""
+    try:
+        module = importlib.import_module(module_name)
+        classes = _get_discovered_classes_from_module(module)
+        for tool_class in classes:
+            name = get_tool_name(tool_class)
+            if name:
+                tools_map[name] = tool_class
+    except Exception:  # pylint: disable=broad-except
+        # Broad catch to skip broken modules during discovery
+        pass
+
+
+def _walk_and_map_package(package: Any, tools_map: dict[str, type]) -> None:
+    """Walk through a package and map all tools found."""
+    try:
+        # Walk packages using the package's path and name
+        for _, module_name, _ in pkgutil.walk_packages(package.__path__, package.__name__ + "."):
+            if _should_skip_module(module_name):
+                continue  # pragma: no cover
 
-        if isinstance(ref, type) and issubclass(ref, BaseTool):
-            return True
-        if isinstance(ref, BaseTool):
-            return True
-    except ImportError:
+            _import_and_map_module(module_name, tools_map)
+    except Exception:  # pylint: disable=broad-except
+        # Broad catch for walk_packages failure
         pass
 
-    return False
+
+def _get_all_aip_agents_tools() -> dict[str, type]:
+    """Discover and map all tools in aip_agents.tools (once per session)."""
+    global _DISCOVERED_TOOLS  # pylint: disable=global-statement
+    if _DISCOVERED_TOOLS is None:
+        _DISCOVERED_TOOLS = {}
+        try:
+            package = importlib.import_module(_AIP_AGENTS_TOOLS)
+            if hasattr(package, "__path__"):
+                _walk_and_map_package(package, _DISCOVERED_TOOLS)
+        except (ImportError, AttributeError):
+            pass
+    return _DISCOVERED_TOOLS
+
+
+@lru_cache(maxsize=128)
+def find_aip_agents_tool_class(name: str) -> type | None:
+    """Find and return a native tool class by tool name.
+
+    Searches aip_agents.tools submodules for BaseTool subclasses
+    with matching 'name' attribute. Uses caching to improve performance.
+
+    Note:
+        Results are discovered once per session and cached. If tools are
+        dynamically added to the path after the first call, they may not
+        be discovered until the session restarts.
+
+    Args:
+        name (str): The tool name to search for (e.g., "google_serper").
+
+    Returns:
+        type|None: The discovered tool class, or None if not found.
+
+    Examples:
+        >>> find_aip_agents_tool_class("google_serper")
+        <class 'aip_agents.tools.web_search.serper_tool.GoogleSerperTool'>
+
+        >>> find_aip_agents_tool_class("nonexistent")
+        None
+    """
+    return _get_all_aip_agents_tools().get(name)
+
+
+def clear_discovery_cache() -> None:
+    """Clear the tool discovery cache (internal use for testing)."""
+    global _DISCOVERED_TOOLS  # pylint: disable=global-statement
+    _DISCOVERED_TOOLS = None
+    find_aip_agents_tool_class.cache_clear()
 
 
 def is_tool_plugin_decorator(decorator: ast.expr) -> bool:

{glaip_sdk-0.7.6.dist-info → glaip_sdk-0.7.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: glaip-sdk
-Version: 0.7.6
+Version: 0.7.8
 Summary: Python SDK and CLI for GL AIP (GDP Labs AI Agent Package) - Build, run, and manage AI agents
 Author-email: Raymond Christopher <raymond.christopher@gdplabs.id>
 License: MIT

{glaip_sdk-0.7.6.dist-info → glaip_sdk-0.7.8.dist-info}/RECORD

@@ -7,10 +7,10 @@ glaip_sdk/rich_components.py,sha256=44Z0V1ZQleVh9gUDGwRR5mriiYFnVGOhm7fFxZYbP8c,
 glaip_sdk/agents/__init__.py,sha256=VfYov56edbWuySXFEbWJ_jLXgwnFzPk1KB-9-mfsUCc,776
 glaip_sdk/agents/base.py,sha256=GQnzCw2cqlrbxwdoWFfhBcBlEDgubY4tlD6gr1b3zps,44539
 glaip_sdk/cli/__init__.py,sha256=xCCfuF1Yc7mpCDcfhHZTX0vizvtrDSLeT8MJ3V7m5A0,156
-glaip_sdk/cli/account_store.py,sha256=TK4iTV93Q1uD9mCY_2ZMT6EazHKU2jX0qhgWfEM4V-4,18459
+glaip_sdk/cli/account_store.py,sha256=u_memecwEQssustZs2wYBrHbEmKUlDfmmL-zO1F3n3A,19034
 glaip_sdk/cli/agent_config.py,sha256=YAbFKrTNTRqNA6b0i0Q3pH-01rhHDRi5v8dxSFwGSwM,2401
 glaip_sdk/cli/auth.py,sha256=bqOHMGIOCg3KXssme3uJBBjEbK0rCEppQ6oq-gJ-hzA,24276
-glaip_sdk/cli/config.py,sha256=s0_xBB1e5YE4I_Wc4q-ayY3dwsBU1JrHAF-8ySlim7Y,3040
+glaip_sdk/cli/config.py,sha256=hFKQSdqELQZLKBuFnhEirNLDyPJwEmpQuD8nHuWxokg,3051
 glaip_sdk/cli/constants.py,sha256=zqcVtzfj6huW97gbCmhkFqntge1H-c1vnkGqTazADgU,895
 glaip_sdk/cli/context.py,sha256=--Y5vc6lgoAV7cRoUAr9UxSQaLmkMg29FolA7EwoRqM,3803
 glaip_sdk/cli/display.py,sha256=ojgWdGeD5KUnGOmWNqqK4JP-1EaWHWX--DWze3BmIz0,12137
@@ -23,6 +23,7 @@ glaip_sdk/cli/mcp_validators.py,sha256=cwbz7p_p7_9xVuuF96OBQOdmEgo5UObU6iWWQ2X03
 glaip_sdk/cli/pager.py,sha256=TmiMDNpUMuZju7QJ6A_ITqIoEf8Dhv8U6mTXx2Fga1k,7935
 glaip_sdk/cli/resolution.py,sha256=AGvv7kllLcuvk_jdaArJqH3lId4IDEXpHceRZwy14xY,2448
 glaip_sdk/cli/rich_helpers.py,sha256=kO47N8e506rxrN6Oc9mbAWN3Qb536oQPWZy1s9A616g,819
+glaip_sdk/cli/tui_settings.py,sha256=ey9bSlolEj3_SMmjVVV_PY0FkfH1psAFPOl03NlykvI,3867
 glaip_sdk/cli/update_notifier.py,sha256=0zpWxr4nSyz0tiLWyC7EEO2deAnVmsRcVlMV79G2QMI,18049
 glaip_sdk/cli/validators.py,sha256=k4J2ACYJPF6UmWJfENt9OHWdp4RNArVxR3hoeqauO88,5629
 glaip_sdk/cli/commands/__init__.py,sha256=6Z3ASXDut0lAbUX_umBFtxPzzFyqoiZfVeTahThFu1A,219
@@ -80,10 +81,10 @@ glaip_sdk/cli/slash/remote_runs_controller.py,sha256=a5X5rYgb9l6dHhvTewRUCj-hAo7
 glaip_sdk/cli/slash/session.py,sha256=Zn2hXND_Tfameh_PI8g4VIMd7GPWxwhtPNMN9p6cF7M,65081
 glaip_sdk/cli/slash/tui/__init__.py,sha256=oBUzeoslYwPKVlhqhgg4I7480b77vQNc9ec0NgdTC1s,977
 glaip_sdk/cli/slash/tui/accounts.tcss,sha256=BCjIuTetmVjydv6DCliY38Cze2LUEu7IY44sL5nIuLU,1194
-glaip_sdk/cli/slash/tui/accounts_app.py,sha256=6ihnAnzKD49eeXYW3dYWUAdUEyoXNFwoEoi3kS3WtXM,35999
+glaip_sdk/cli/slash/tui/accounts_app.py,sha256=baxAN1kUs3xyOvk6VCrdwcdEL89D37FkLlFP8mXrKHE,42049
 glaip_sdk/cli/slash/tui/background_tasks.py,sha256=SAe1mV2vXB3mJcSGhelU950vf8Lifjhws9iomyIVFKw,2422
 glaip_sdk/cli/slash/tui/clipboard.py,sha256=HL_RWIdONyRmDtTYuDzxJTS_mRcLxuR37Ac9Ug5nh40,4730
-glaip_sdk/cli/slash/tui/context.py,sha256=03mo2kgvpyUcNBYz7G2Uyu7X3FJlSUzVoP5Rt9MCZZY,2141
+glaip_sdk/cli/slash/tui/context.py,sha256=XgHsXPl8LDDwIueP_jhP6xqpx_zHOk0FF19rWob_z5Q,3128
 glaip_sdk/cli/slash/tui/keybind_registry.py,sha256=_rK05BxTxNudYc4iJ9gDxpgeUkjDAq8rarIT-9A-jyM,6739
 glaip_sdk/cli/slash/tui/loading.py,sha256=nW5pv_Tnl9FUOPR3Qf2O5gt1AGHSo3b5-Uofg34F6AE,1909
 glaip_sdk/cli/slash/tui/remote_runs_app.py,sha256=RCrI-c5ilKV6Iy1lz2Aok9xo2Ou02vqcXACMXTdodnE,24716
@@ -91,7 +92,7 @@ glaip_sdk/cli/slash/tui/terminal.py,sha256=iC31XChTL34gXY6vXdSIX3HmD36tuA9EYTPZ2
 glaip_sdk/cli/slash/tui/toast.py,sha256=LP_myZwgnrdowrRxGK24lMlx7iZt7iOwFhrbc4NW0DY,3493
 glaip_sdk/cli/slash/tui/theme/__init__.py,sha256=rtM2ik83YNCRcI1qh_Sf3rnxco2OvCNNT3NbHY6cLvw,432
 glaip_sdk/cli/slash/tui/theme/catalog.py,sha256=G52eU3h8YI9D8XUALVg1KVZ4Lq65VnZdgPS3F_P7XLE,2544
-glaip_sdk/cli/slash/tui/theme/manager.py,sha256=X600J_WIBM1CHgsQeMFGFPuaVAFCINFcBXFWmeD4B5Q,2707
+glaip_sdk/cli/slash/tui/theme/manager.py,sha256=LBnxEMIwz-8cAlZGYk5tIoAJbOJyGYsmDlyuGJ-LlX4,3945
 glaip_sdk/cli/slash/tui/theme/tokens.py,sha256=ympMRny_d-gHtmnPR-lmNZ-C9SGBy2q-MH81l0L1h-Y,1423
 glaip_sdk/cli/transcript/__init__.py,sha256=yiYHyNtebMCu3BXu56Xm5RBC2tDc865q8UGPnoe6QRs,920
 glaip_sdk/cli/transcript/cache.py,sha256=Wi1uln6HP1U6F-MRTrfnxi9bn6XJTxwWXhREIRPoMqQ,17439
@@ -137,7 +138,7 @@ glaip_sdk/registry/__init__.py,sha256=mjvElYE-wwmbriGe-c6qy4on0ccEuWxW_EWWrSbptC
 glaip_sdk/registry/agent.py,sha256=F0axW4BIUODqnttIOzxnoS5AqQkLZ1i48FTeZNnYkhA,5203
 glaip_sdk/registry/base.py,sha256=0x2ZBhiERGUcf9mQeWlksSYs5TxDG6FxBYQToYZa5D4,4143
 glaip_sdk/registry/mcp.py,sha256=kNJmiijIbZL9Btx5o2tFtbaT-WG6O4Xf_nl3wz356Ow,7978
-glaip_sdk/registry/tool.py,sha256=QnbAlk09lYvEb9PEdCsvpg4CGxlLbvvFWBS8WkM1ZoM,12955
+glaip_sdk/registry/tool.py,sha256=c0Ja4rFYMOKs_1yjDLDZxCId4IjQzprwXzX0iIL8Fio,14979
 glaip_sdk/runner/__init__.py,sha256=orJ3nLR9P-n1qMaAMWZ_xRS4368YnDpdltg-bX5BlUk,2210
 glaip_sdk/runner/base.py,sha256=KIjcSAyDCP9_mn2H4rXR5gu1FZlwD9pe0gkTBmr6Yi4,2663
 glaip_sdk/runner/deps.py,sha256=Du3hr2R5RHOYCRAv7RVmx661x-ayVXIeZ8JD7ODirTA,3884
@@ -149,12 +150,12 @@ glaip_sdk/runner/mcp_adapter/langchain_mcp_adapter.py,sha256=b58GuadPz7q7aXoJyTY
 glaip_sdk/runner/mcp_adapter/mcp_config_builder.py,sha256=fQcRaueDuyUzXUSVn9N8QxfaYNIteEO_R_uibx_0Icw,3440
 glaip_sdk/runner/tool_adapter/__init__.py,sha256=scv8sSPxSWjlSNEace03R230YbmWgphLgqINKvDjWmM,480
 glaip_sdk/runner/tool_adapter/base_tool_adapter.py,sha256=nL--eicV0St5_0PZZSEhRurHDZHNwhGN2cKOUh0C5IY,1400
-glaip_sdk/runner/tool_adapter/langchain_tool_adapter.py,sha256=goSSDOpubuplsKpfemlbesf_bZBdpDKSTqLILvApcjA,7438
+glaip_sdk/runner/tool_adapter/langchain_tool_adapter.py,sha256=SgfQM5NgKyYBs34juxv3TCEicJbKgFIVPPZa22tA9AU,8484
 glaip_sdk/schedules/__init__.py,sha256=Ty__lE8ta3a6O7EiEsSXliVOwA3EBLKxKRsjAJt2WUg,482
 glaip_sdk/schedules/base.py,sha256=ZRKWknoxQOYMhX8mjQ7S7oqpy6Wr0xdbzcgIrycsEQ8,9727
 glaip_sdk/tools/__init__.py,sha256=rhGzEqQFCzeMrxmikBuNrMz4PyYczwic28boDKVmoHs,585
-glaip_sdk/tools/base.py,sha256=hkz2NZFHW1PqsRiXh3kKTVLIjMPR274Uwml944vH5tg,16325
-glaip_sdk/utils/__init__.py,sha256=ntohV7cxlY2Yksi2nFuFm_Mg2XVJbBbSJVRej7Mi9YE,2770
+glaip_sdk/tools/base.py,sha256=KRaWWX5cKAvEKtBr4iSOaKQlQ973A4pNOW2KVvA1aYs,17353
+glaip_sdk/utils/__init__.py,sha256=5a1kNLtUriwd1qAT6RU083GOyABS7LMZQacDP4yS9S4,2830
 glaip_sdk/utils/agent_config.py,sha256=RhcHsSOVwOaSC2ggnPuHn36Aa0keGJhs8KGb2InvzRk,7262
 glaip_sdk/utils/bundler.py,sha256=fLumFj1MqqqGA1Mwn05v_cEKPALv3rIPEMvaURpxZ80,15171
 glaip_sdk/utils/client.py,sha256=otPUOIDvLCCsvFBNR8YMZFtRrORggmvvlFjl3YeeTqQ,3121
@@ -172,7 +173,7 @@ glaip_sdk/utils/run_renderer.py,sha256=d_VMI6LbvHPUUeRmGqh5wK_lHqDEIAcym2iqpbtDa
 glaip_sdk/utils/runtime_config.py,sha256=Gl9-CQ4lYZ39vRSgtdfcSU3CXshVDDuTOdSzjvsCgG0,14070
 glaip_sdk/utils/serialization.py,sha256=z-qpvWLSBrGK3wbUclcA1UIKLXJedTnMSwPdq-FF4lo,13308
 glaip_sdk/utils/sync.py,sha256=71egWp5qm_8tYpWZyGazvnP4NnyW16rcmzjGVicmQEE,6043
-glaip_sdk/utils/tool_detection.py,sha256=6dHp0naLnvY6jwy_38k4kyTgQnizgcsq9hpeLSjAmcc,1471
+glaip_sdk/utils/tool_detection.py,sha256=B7xze014TZyqWI4JqLhkZrbtT5h32CjQEXRswtdcljI,9808
 glaip_sdk/utils/tool_storage_provider.py,sha256=lampwUeWu4Uy8nBG7C4ZT-M6AHoWZS0m67HdLx21VDg,5396
 glaip_sdk/utils/validation.py,sha256=hB_k3lvHdIFUiSwHStrC0Eqnhx0OG2UvwqASeem0HuQ,6859
 glaip_sdk/utils/a2a/__init__.py,sha256=_X8AvDOsHeppo5n7rP5TeisVxlAdkZDTFReBk_9lmxo,876
@@ -206,8 +207,8 @@ glaip_sdk/utils/rendering/steps/format.py,sha256=Chnq7OBaj8XMeBntSBxrX5zSmrYeGcO
 glaip_sdk/utils/rendering/steps/manager.py,sha256=BiBmTeQMQhjRMykgICXsXNYh1hGsss-fH9BIGVMWFi0,13194
 glaip_sdk/utils/rendering/viewer/__init__.py,sha256=XrxmE2cMAozqrzo1jtDFm8HqNtvDcYi2mAhXLXn5CjI,457
 glaip_sdk/utils/rendering/viewer/presenter.py,sha256=mlLMTjnyeyPVtsyrAbz1BJu9lFGQSlS-voZ-_Cuugv0,5725
-glaip_sdk-0.7.6.dist-info/METADATA,sha256=jGATytvWTrk-Fe3kv_N6mxfD0vkpmDCsO4odOnOzPPM,8365
-glaip_sdk-0.7.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-glaip_sdk-0.7.6.dist-info/entry_points.txt,sha256=NkhO6FfgX9Zrjn63GuKphf-dLw7KNJvucAcXc7P3aMk,54
-glaip_sdk-0.7.6.dist-info/top_level.txt,sha256=td7yXttiYX2s94-4wFhv-5KdT0rSZ-pnJRSire341hw,10
-glaip_sdk-0.7.6.dist-info/RECORD,,
+glaip_sdk-0.7.8.dist-info/METADATA,sha256=srMagYZpJce1Yhs0KJo0636l_He6YAFCS1HVtEY8k9Q,8365
+glaip_sdk-0.7.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+glaip_sdk-0.7.8.dist-info/entry_points.txt,sha256=NkhO6FfgX9Zrjn63GuKphf-dLw7KNJvucAcXc7P3aMk,54
+glaip_sdk-0.7.8.dist-info/top_level.txt,sha256=td7yXttiYX2s94-4wFhv-5KdT0rSZ-pnJRSire341hw,10
+glaip_sdk-0.7.8.dist-info/RECORD,,