glaip-sdk 0.7.9__py3-none-any.whl → 0.7.10__py3-none-any.whl

glaip_sdk/agents/base.py

@@ -54,6 +54,7 @@ from glaip_sdk.utils.resource_refs import is_uuid
 
 if TYPE_CHECKING:
     from glaip_sdk.client.schedules import AgentScheduleManager
+    from glaip_sdk.guardrails import GuardrailManager
     from glaip_sdk.models import AgentResponse
     from glaip_sdk.registry import AgentRegistry, MCPRegistry, ToolRegistry
 
@@ -130,6 +131,7 @@ class Agent:
         agents: list | None = None,
         mcps: list | None = None,
         model: str | None = _UNSET,  # type: ignore[assignment]
+        guardrail: GuardrailManager | None = None,
         _client: Any = None,
         **kwargs: Any,
     ) -> None:
@@ -147,7 +149,9 @@ class Agent:
             agents: List of sub-agents (Agent classes, instances, or strings).
             mcps: List of MCPs.
             model: Model identifier.
+            guardrail: The guardrail manager for content safety.
             _client: Internal client reference (set automatically).
+
             **kwargs: Additional configuration parameters:
                 - timeout: Execution timeout in seconds.
                 - metadata: Optional metadata dictionary.
@@ -173,6 +177,7 @@ class Agent:
         self._agents = agents
         self._mcps = mcps
         self._model = model
+        self._guardrail = guardrail
         self._language_model_id: str | None = None
         # Extract parameters from kwargs with _UNSET defaults
         self._timeout = kwargs.pop("timeout", Agent._UNSET)  # type: ignore[assignment]
@@ -452,6 +457,11 @@ class Agent:
             return self._mcp_configs
         return None
 
+    @property
+    def guardrail(self) -> GuardrailManager | None:
+        """The guardrail manager for content safety."""
+        return self._guardrail
+
     @property
     def a2a_profile(self) -> dict[str, Any] | None:
         """A2A (Agent-to-Agent) profile configuration.
@@ -547,11 +557,20 @@ class Agent:
 
         # Handle agent_config with timeout
         # The timeout property is a convenience that maps to agent_config.execution_timeout
-        agent_config = dict(self.agent_config) if self.agent_config else {}
+        raw_config = self.agent_config if self.agent_config is not self._UNSET else {}
+        agent_config = dict(raw_config) if raw_config else {}
+
         if self.timeout and "execution_timeout" not in agent_config:
             agent_config["execution_timeout"] = self.timeout
-        if agent_config:
-            config["agent_config"] = agent_config
+
+        if self.guardrail:
+            from glaip_sdk.guardrails.serializer import (  # noqa: PLC0415
+                serialize_guardrail_manager,
+            )
+
+            agent_config["guardrails"] = serialize_guardrail_manager(self.guardrail)
+
+        config["agent_config"] = agent_config
 
         # Handle tool_configs - resolve tool names/classes to IDs
         if self.tool_configs:
@@ -583,11 +602,20 @@ class Agent:
 
         Returns:
             List of resolved MCP IDs for the API payload.
+
+        Raises:
+            ValueError: If an MCP fails to resolve to a valid ID.
         """
         if not self.mcps:
             return []
 
-        return [registry.resolve(mcp_ref).id for mcp_ref in self.mcps]
+        resolved_ids: list[str] = []
+        for mcp_ref in self.mcps:
+            mcp = registry.resolve(mcp_ref)
+            if not mcp.id:
+                raise ValueError(f"Failed to resolve ID for MCP: {mcp_ref}")
+            resolved_ids.append(mcp.id)
+        return resolved_ids
 
     def _resolve_tools(self, registry: ToolRegistry) -> list[str]:
         """Resolve tool references to IDs using ToolRegistry.
@@ -601,12 +629,20 @@ class Agent:
 
         Returns:
             List of resolved tool IDs for the API payload.
+
+        Raises:
+            ValueError: If a tool fails to resolve to a valid ID.
         """
         if not self.tools:
             return []
 
-        # Resolve each tool reference to a Tool object, extract ID
-        return [registry.resolve(tool_ref).id for tool_ref in self.tools]
+        resolved_ids: list[str] = []
+        for tool_ref in self.tools:
+            tool = registry.resolve(tool_ref)
+            if not tool.id:
+                raise ValueError(f"Failed to resolve ID for tool: {tool_ref}")
+            resolved_ids.append(tool.id)
+        return resolved_ids
 
     def _resolve_tool_configs(self, registry: ToolRegistry) -> dict[str, Any]:
         """Resolve tool_configs keys from tool names/classes to tool IDs.
@@ -649,6 +685,8 @@ class Agent:
             try:
                 # Resolve key (tool name/class) to Tool object, get ID
                 tool = registry.resolve(key)
+                if not tool.id:
+                    raise ValueError(f"Resolved tool has no ID: {key}")
                 resolved[tool.id] = config
             except (ValueError, KeyError) as e:
                 raise ValueError(f"Failed to resolve tool config key: {key}") from e
@@ -684,6 +722,8 @@ class Agent:
                     resolved_id = key
                 else:
                     mcp = registry.resolve(key)
+                    if not mcp.id:
+                        raise ValueError(f"Resolved MCP has no ID: {key}")
                     resolved_id = mcp.id
 
                 if resolved_id in resolved:
@@ -699,7 +739,7 @@ class Agent:
 
         return resolved
 
-    def _resolve_agents(self, registry: AgentRegistry) -> list:
+    def _resolve_agents(self, registry: AgentRegistry) -> list[str]:
         """Resolve sub-agent references using AgentRegistry.
 
         Uses the global AgentRegistry to cache Agent objects across deployments.
@@ -711,12 +751,20 @@ class Agent:
 
         Returns:
             List of resolved agent IDs for the API payload.
+
+        Raises:
+            ValueError: If an agent fails to resolve to a valid ID.
         """
         if not self.agents:
             return []
 
-        # Resolve each agent reference to a deployed Agent, extract ID
-        return [registry.resolve(agent_ref).id for agent_ref in self.agents]
+        resolved_ids: list[str] = []
+        for agent_ref in self.agents:
+            agent = registry.resolve(agent_ref)
+            if not agent.id:
+                raise ValueError(f"Failed to resolve ID for agent: {agent_ref}")
+            resolved_ids.append(agent.id)
+        return resolved_ids
 
     def _create_or_update_agent(
         self,
@@ -807,6 +855,8 @@ class Agent:
         Returns:
             Dictionary containing Agent attributes.
         """
+        config = self._build_config(get_tool_registry(), get_mcp_registry())
+
         data = {
             "id": self._id,
             "name": self.name,
@@ -820,10 +870,11 @@ class Agent:
             "mcps": self.mcps,
             "timeout": self.timeout,
             "metadata": self.metadata,
-            "agent_config": self.agent_config,
+            "agent_config": config.get("agent_config"),
             "tool_configs": self.tool_configs,
             "mcp_configs": self.mcp_configs,
             "a2a_profile": self.a2a_profile,
+            "guardrail": self.guardrail,
             "created_at": self._created_at,
             "updated_at": self._updated_at,
         }

glaip_sdk/cli/slash/remote_runs_controller.py

@@ -294,12 +294,14 @@ class RemoteRunsController:
             fetch_detail=fetch_detail,
             export_run=export_run,
         )
+        tui_ctx = getattr(self.session, "tui_ctx", None)
         page, limit, cursor = run_remote_runs_textual(
             runs_page,
             state.get("cursor", 0),
             callbacks,
             agent_name=agent_name,
             agent_id=agent_id,
+            ctx=tui_ctx,
         )
         state["page"] = page
         state["limit"] = limit

glaip_sdk/cli/slash/tui/accounts.tcss

@@ -3,6 +3,18 @@
  * Keep layout compact: filter sits tight above the table; header shows active account.
  */
 
+Screen {
+    layers: base toasts;
+}
+
+#toast-container {
+    width: 100%;
+    height: auto;
+    dock: top;
+    align: right top;
+    layer: toasts;
+}
+
 #header-info {
     padding: 0 1 0 1;
     margin: 0;

glaip_sdk/cli/slash/tui/accounts_app.py

@@ -18,7 +18,7 @@ import asyncio
 import logging
 from collections.abc import Callable
 from dataclasses import dataclass
-from typing import Any
+from typing import Any, cast
 
 from glaip_sdk.cli.account_store import AccountStore, AccountStoreError, get_account_store
 from glaip_sdk.cli.commands.common_config import check_connection_with_reason
@@ -34,7 +34,15 @@ 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
+
+try:  # pragma: no cover - optional dependency
+    from glaip_sdk.cli.slash.tui.toast import ClipboardToastMixin, Toast, ToastBus, ToastHandlerMixin, ToastVariant
+except Exception:  # pragma: no cover - optional dependency
+    ClipboardToastMixin = object  # type: ignore[assignment, misc]
+    Toast = None  # type: ignore[assignment]
+    ToastBus = None  # type: ignore[assignment]
+    ToastHandlerMixin = object  # type: ignore[assignment, misc]
+    ToastVariant = None  # type: ignore[assignment]
 from glaip_sdk.cli.validators import validate_api_key
 from glaip_sdk.utils.validation import validate_url
 
@@ -450,7 +458,9 @@ class ConfirmDeleteModal(_ConfirmDeleteBase):  # pragma: no cover - interactive
         self.dismiss(self._name)
 
 
-class AccountsTextualApp(BackgroundTaskMixin, _AppBase):  # pragma: no cover - interactive
+class AccountsTextualApp(  # pragma: no cover - interactive
+    ToastHandlerMixin, ClipboardToastMixin, BackgroundTaskMixin, _AppBase
+):
     """Textual application for browsing accounts."""
 
     CSS_PATH = CSS_FILE_NAME
@@ -494,7 +504,6 @@ class AccountsTextualApp(BackgroundTaskMixin, _AppBase):  # pragma: no cover - i
         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
@@ -526,6 +535,8 @@ class AccountsTextualApp(BackgroundTaskMixin, _AppBase):  # pragma: no cover - i
         main.styles.height = "1fr"
         main.styles.padding = (0, 0)
         yield main
+        if Toast is not None:
+            yield Container(Toast(), id="toast-container")
         yield Horizontal(
             LoadingIndicator(id=ACCOUNTS_LOADING_ID.lstrip("#")),
             Static("", id=STATUS_ID.lstrip("#")),
@@ -555,11 +566,14 @@ class AccountsTextualApp(BackgroundTaskMixin, _AppBase):  # pragma: no cover - i
         self._register_keybinds()
 
     def _initialize_context_services(self) -> None:
+        def _notify(message: ToastBus.Changed) -> None:
+            self.post_message(message)
+
         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.toasts is None and ToastBus is not None:
+                self._ctx.toasts = ToastBus(on_change=_notify)
             if self._ctx.clipboard is None:
                 self._ctx.clipboard = ClipboardAdapter(terminal=self._ctx.terminal)
             self._keybinds = self._ctx.keybinds
@@ -571,10 +585,11 @@ class AccountsTextualApp(BackgroundTaskMixin, _AppBase):  # pragma: no cover - i
                 tty=True, ansi=True, osc52=False, osc11_bg=None, mouse=False, truecolor=False
             )
             self._clipboard = ClipboardAdapter(terminal=terminal)
+            if ToastBus is not None:
+                self._toast_bus = ToastBus(on_change=_notify)
 
     def _prepare_toasts(self) -> None:
-        """Prepare toast system by marking ready and clearing any existing toasts."""
-        self._toast_ready = True
+        """Prepare toast system by clearing any existing toasts."""
         if self._toast_bus:
             self._toast_bus.clear()
 
@@ -768,7 +783,7 @@ class AccountsTextualApp(BackgroundTaskMixin, _AppBase):  # pragma: no cover - i
         self._hide_loading()
         self._is_switching = False
         error_msg = f"Switch failed to start: {exc}"
-        if self._toast_ready and self._toast_bus:
+        if self._toast_bus:
             self._toast_bus.show(message=error_msg, variant="error")
         try:
             self._set_status(error_msg, "red")
@@ -800,7 +815,7 @@ class AccountsTextualApp(BackgroundTaskMixin, _AppBase):  # pragma: no cover - i
             if switched:
                 self._active_account = name
                 status_msg = message or f"Switched to '{name}'."
-                if self._toast_ready and self._toast_bus:
+                if self._toast_bus:
                     self._toast_bus.show(message=status_msg, variant="success")
                 self._update_header()
                 self._reload_rows()
@@ -913,34 +928,54 @@ class AccountsTextualApp(BackgroundTaskMixin, _AppBase):  # pragma: no cover - i
             return
 
         text = f"Account: {name}\nURL: {account.get('api_url', '')}"
-        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:
+        adapter = self._clipboard_adapter()
+        writer = self._osc52_writer()
+        if writer:
+            result = adapter.copy(text, writer=writer)
+        else:
             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__))
+        self._handle_copy_result(name, result)
 
     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)
+            if self._toast_bus:
+                self._toast_bus.copy_success(f"Account '{name}'")
             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)
+            if self._toast_bus and ToastVariant is not None:
+                self._toast_bus.show(message=f"Copy failed: {result.message}", variant=ToastVariant.WARNING)
             self._set_status(f"Copy failed: {result.message}", "red")
 
+    def _clipboard_adapter(self) -> ClipboardAdapter:
+        if self._ctx is not None and self._ctx.clipboard is not None:
+            return cast(ClipboardAdapter, self._ctx.clipboard)
+        if self._clipboard is not None:
+            return self._clipboard
+        adapter = ClipboardAdapter(terminal=self._ctx.terminal if self._ctx else None)
+        if self._ctx is not None:
+            self._ctx.clipboard = adapter
+        else:
+            self._clipboard = adapter
+        return adapter
+
+    def _osc52_writer(self) -> Callable[[str], Any] | None:
+        try:
+            console = getattr(self, "console", None)
+        except Exception:
+            return None
+        if console is None:
+            return None
+        output = getattr(console, "file", None)
+        if output is None:
+            return None
+
+        def _write(sequence: str, _output=output) -> None:
+            _output.write(sequence)
+            _output.flush()
+
+        return _write
+
     def _check_env_lock_hotkey(self) -> bool:
         """Prevent mutations when env credentials are present."""
         if not self._is_env_locked():

glaip_sdk/cli/slash/tui/clipboard.py

@@ -45,6 +45,36 @@ _SUBPROCESS_COMMANDS: dict[ClipboardMethod, list[str]] = {
     ClipboardMethod.CLIP: ["clip"],
 }
 
+_ENV_CLIPBOARD_METHOD = "AIP_TUI_CLIPBOARD_METHOD"
+_ENV_CLIPBOARD_FORCE = "AIP_TUI_CLIPBOARD_FORCE"
+_ENV_METHOD_MAP = {
+    "osc52": ClipboardMethod.OSC52,
+    "pbcopy": ClipboardMethod.PBCOPY,
+    "xclip": ClipboardMethod.XCLIP,
+    "xsel": ClipboardMethod.XSEL,
+    "wl-copy": ClipboardMethod.WL_COPY,
+    "wl_copy": ClipboardMethod.WL_COPY,
+    "clip": ClipboardMethod.CLIP,
+    "none": ClipboardMethod.NONE,
+}
+
+
+def _resolve_env_method() -> ClipboardMethod | None:
+    raw = os.getenv(_ENV_CLIPBOARD_METHOD)
+    if not raw:
+        return None
+    value = raw.strip().lower()
+    if value in ("auto", "default"):
+        return None
+    return _ENV_METHOD_MAP.get(value)
+
+
+def _is_env_force_enabled() -> bool:
+    raw = os.getenv(_ENV_CLIPBOARD_FORCE)
+    if not raw:
+        return False
+    return raw.strip().lower() in {"1", "true", "yes", "on"}
+
 
 class ClipboardAdapter:
     """Cross-platform clipboard access with OSC 52 fallback."""
@@ -57,7 +87,16 @@ class ClipboardAdapter:
     ) -> None:
         """Initialize the adapter."""
         self._terminal = terminal
-        self._method = method or self._detect_method()
+        self._force_method = False
+        if method is not None:
+            self._method = method
+        else:
+            env_method = _resolve_env_method()
+            if env_method is not None:
+                self._method = env_method
+                self._force_method = _is_env_force_enabled()
+            else:
+                self._method = self._detect_method()
 
     @property
     def method(self) -> ClipboardMethod:
@@ -77,25 +116,34 @@ class ClipboardAdapter:
 
         command = _SUBPROCESS_COMMANDS.get(self._method)
         if command is None:
+            if self._force_method:
+                return ClipboardResult(False, self._method, "Forced clipboard method unavailable.")
             return self._copy_osc52(text, writer=writer)
 
         result = self._copy_subprocess(command, text)
         if not result.success:
+            if self._force_method:
+                return result
             return self._copy_osc52(text, writer=writer)
 
         return result
 
     def _detect_method(self) -> ClipboardMethod:
+        system = platform.system()
+        method = ClipboardMethod.NONE
+        if system == "Darwin":
+            method = self._detect_darwin_method()
+        elif system == "Linux":
+            method = self._detect_linux_method()
+        elif system == "Windows":
+            method = self._detect_windows_method()
+
+        if method is not ClipboardMethod.NONE:
+            return method
+
         if self._terminal.osc52 if self._terminal else detect_osc52_support():
             return ClipboardMethod.OSC52
 
-        system = platform.system()
-        if system == "Darwin":
-            return self._detect_darwin_method()
-        if system == "Linux":
-            return self._detect_linux_method()
-        if system == "Windows":
-            return self._detect_windows_method()
         return ClipboardMethod.NONE
 
     def _detect_darwin_method(self) -> ClipboardMethod: