glaip-sdk 0.6.5b9__py3-none-any.whl → 0.6.8b1__py3-none-any.whl

glaip_sdk/agents/base.py

@@ -46,6 +46,8 @@ import inspect
 import logging
 import warnings
 from collections.abc import AsyncGenerator
+
+
 from pathlib import Path
 from typing import TYPE_CHECKING, Any
 
@@ -869,7 +871,7 @@ class Agent:
             ValueError: If the agent hasn't been deployed yet.
             RuntimeError: If client is not available.
         """
-        if not self.id:
+        if not self.id:  # pragma: no cover - defensive: called only when self.id is truthy
             raise ValueError(_AGENT_NOT_DEPLOYED_MSG)
         if not self._client:
             raise RuntimeError(_CLIENT_NOT_AVAILABLE_MSG)
@@ -893,6 +895,48 @@ class Agent:
         call_kwargs.update(kwargs)
         return agent_client, call_kwargs
 
+    def _get_local_runner_or_raise(self) -> Any:
+        """Get the local runner if available, otherwise raise ValueError.
+
+        Returns:
+            The default local runner instance.
+
+        Raises:
+            ValueError: If local runtime is not available.
+        """
+        if check_local_runtime_available():
+            return get_default_runner()
+        raise ValueError(f"{_AGENT_NOT_DEPLOYED_MSG}\n\n{get_local_runtime_missing_message()}")
+
+    def _prepare_local_runner_kwargs(
+        self,
+        message: str,
+        verbose: bool,
+        runtime_config: dict[str, Any] | None,
+        chat_history: list[dict[str, str]] | None,
+        **kwargs: Any,
+    ) -> dict[str, Any]:
+        """Prepare kwargs for local runner execution.
+
+        Args:
+            message: The message to send to the agent.
+            verbose: If True, print streaming output to console.
+            runtime_config: Optional runtime configuration.
+            chat_history: Optional list of prior conversation messages.
+            **kwargs: Additional arguments.
+
+        Returns:
+            Dictionary of prepared kwargs for runner.run() or runner.arun().
+        """
+        return {
+            "agent": self,
+            "message": message,
+            "verbose": verbose,
+            "runtime_config": runtime_config,
+            "chat_history": chat_history,
+            **kwargs,
+        }
+
     def run(
         self,
         message: str,
@@ -943,32 +987,29 @@ class Agent:
             return agent_client.run_agent(**call_kwargs)
 
         # Local execution path (agent is not deployed)
-        if check_local_runtime_available():
-            runner = get_default_runner()
-            return runner.run(
-                agent=self,
-                message=message,
-                verbose=verbose,
-                runtime_config=runtime_config,
-                chat_history=chat_history,
-                **kwargs,
-            )
-
-        # Neither deployed nor local runtime available - provide actionable error
-        raise ValueError(f"{_AGENT_NOT_DEPLOYED_MSG}\n\n{get_local_runtime_missing_message()}")
+        runner = self._get_local_runner_or_raise()
+        local_kwargs = self._prepare_local_runner_kwargs(message, verbose, runtime_config, chat_history, **kwargs)
+        return runner.run(**local_kwargs)
 
     async def arun(
         self,
         message: str,
         verbose: bool = False,
         runtime_config: dict[str, Any] | None = None,
+        chat_history: list[dict[str, str]] | None = None,
         **kwargs: Any,
     ) -> AsyncGenerator[dict, None]:
         """Run the agent asynchronously with streaming output.
 
+        Supports two execution modes:
+        - **Server-backed**: When the agent is deployed (has an ID), execution
+          happens via the AIP backend server with streaming.
+        - **Local**: When the agent is not deployed and glaip-sdk[local] is installed,
+          execution happens locally via aip-agents (no server required).
+
         Args:
             message: The message to send to the agent.
-            verbose: If True, print streaming output to console.
+            verbose: If True, print streaming output to console. Defaults to False.
             runtime_config: Optional runtime configuration for tools, MCPs, and agents.
                 Keys can be SDK objects, UUIDs, or names. Example:
                 {
@@ -976,20 +1017,44 @@ class Agent:
                     "mcp_configs": {"mcp-id": {"setting": "on"}},
                     "agent_config": {"planning": True},
                 }
+                Defaults to None.
+            chat_history: Optional list of prior conversation messages for context.
+                Each message is a dict with "role" and "content" keys.
+                Defaults to None.
             **kwargs: Additional arguments to pass to the run API.
 
         Yields:
             Streaming response chunks from the agent.
 
         Raises:
-            ValueError: If the agent hasn't been deployed yet.
-            RuntimeError: If client is not available.
+            ValueError: If the agent is not deployed and local runtime is not available.
+            RuntimeError: If server-backed execution fails due to client issues.
         """
-        agent_client, call_kwargs = self._prepare_run_kwargs(
-            message, verbose, runtime_config or kwargs.get("runtime_config"), **kwargs
-        )
-        async for chunk in agent_client.arun_agent(**call_kwargs):
-            yield chunk
+        # Backend routing: deployed agents use server, undeployed use local (if available)
+        if self.id:
+            # Server-backed execution path (agent is deployed)
+            agent_client, call_kwargs = self._prepare_run_kwargs(
+                message, verbose, runtime_config or kwargs.get("runtime_config"), **kwargs
+            )
+            if chat_history is not None:
+                call_kwargs["chat_history"] = chat_history
+
+            async for chunk in agent_client.arun_agent(**call_kwargs):
+                yield chunk
+            return
+
+        # Local execution path (agent is not deployed)
+        runner = self._get_local_runner_or_raise()
+        local_kwargs = self._prepare_local_runner_kwargs(message, verbose, runtime_config, chat_history, **kwargs)
+        result = await runner.arun(**local_kwargs)
+        # Yield a final_response event for consistency with server-backed execution
+        # Include event_type for A2A event shape parity
+        yield {
+            "event_type": "final_response",
+            "metadata": {"kind": "final_response"},
+            "content": result,
+            "is_final": True,
+        }
 
     def update(self, **kwargs: Any) -> Agent:
         """Update the deployed agent with new configuration.

glaip_sdk/cli/commands/configure.py

@@ -22,7 +22,7 @@ from glaip_sdk.branding import ACCENT_STYLE, ERROR_STYLE, INFO, NEUTRAL, SUCCESS
 # Optional import for gitignore support; warn when missing to avoid silent expansion
 try:
     import pathspec  # type: ignore[import-untyped]  # noqa: PLC0415
-except ImportError:
+except ImportError:  # pragma: no cover - optional dependency
     pathspec = None  # type: ignore[assignment]
 from glaip_sdk.cli.account_store import get_account_store
 from glaip_sdk.cli.commands.common_config import check_connection, render_branding_header

glaip_sdk/cli/slash/accounts_controller.py

@@ -151,79 +151,147 @@ class AccountsController:
 
     def _render_textual(self, rows: list[dict[str, str | bool]], store: AccountStore, env_lock: bool) -> None:
         """Launch the Textual accounts browser."""
-        callbacks = AccountsTUICallbacks(switch_account=lambda name: self._switch_account(store, name, env_lock))
+        active_before = store.get_active_account()
+        notified = False
+
+        def _switch_in_textual(name: str) -> tuple[bool, str]:
+            nonlocal notified
+            switched, message = self._switch_account(
+                store,
+                name,
+                env_lock,
+                emit_console=False,
+                invalidate_session=True,
+            )
+            if switched:
+                notified = True
+            return switched, message
+
+        callbacks = AccountsTUICallbacks(switch_account=_switch_in_textual)
         active = next((row["name"] for row in rows if row.get("active")), None)
-        run_accounts_textual(rows, active_account=active, env_lock=env_lock, callbacks=callbacks)
-        # Exit snapshot: surface a success banner when a switch occurred inside the TUI
-        active_after = store.get_active_account() or "default"
+        try:
+            run_accounts_textual(rows, active_account=active, env_lock=env_lock, callbacks=callbacks)
+        except Exception as exc:  # pragma: no cover - defensive around Textual failures
+            self.console.print(f"[{WARNING_STYLE}]Accounts browser exited unexpectedly: {exc}[/]")
+
+        # Exit snapshot: surface a success banner when a switch occurred inside the TUI.
+        # Always notify when the active account changed, even if Textual raised.
+        active_after = store.get_active_account()
+        if active_after != active_before and not notified:
+            self._notify_account_switched(active_after)
         if active_after != active:
             host_after = ""
-            account_after = store.get_account(active_after) if hasattr(store, "get_account") else None
+            display_account = active_after or "default"
+            account_after = store.get_account(display_account) if hasattr(store, "get_account") else None
             if account_after:
                 host_after = account_after.get("api_url", "")
             host_suffix = f" • {host_after}" if host_after else ""
             self.console.print(
                 AIPPanel(
-                    f"[{SUCCESS_STYLE}]Active account ➜ {active_after}[/]{host_suffix}",
+                    f"[{SUCCESS_STYLE}]Active account ➜ {display_account}[/]{host_suffix}",
                     title="✅ Account Switched",
                     border_style=SUCCESS_STYLE,
                 )
             )
 
-    def _switch_account(self, store: AccountStore, name: str, env_lock: bool) -> tuple[bool, str]:
-        """Validate and switch active account; returns (success, message)."""
+    def _format_connection_error_message(self, error_reason: str, account_name: str, api_url: str) -> str:
+        """Format error message for connection validation failures."""
+        code, detail = self._parse_error_reason(error_reason)
+        if code == "connection_failed":
+            return f"Switch aborted: cannot reach {api_url}. Check URL or network."
+        if code == "api_failed":
+            return f"Switch aborted: API error for '{account_name}'. Check credentials."
+        detail_suffix = f": {detail}" if detail else ""
+        return f"Switch aborted: {code or 'Validation failed'}{detail_suffix}"
+
+    def _emit_error_message(self, msg: str, style: str = ERROR_STYLE) -> None:
+        """Emit an error or warning message to the console."""
+        self.console.print(f"[{style}]{msg}[/]")
+
+    def _validate_account_switch(
+        self, store: AccountStore, name: str, env_lock: bool, emit_console: bool
+    ) -> tuple[bool, str, dict[str, str] | None]:
+        """Validate account switch prerequisites; returns (is_valid, error_msg, account_dict)."""
         if env_lock:
             msg = "Env credentials detected (AIP_API_URL/AIP_API_KEY); switching is disabled."
-            self.console.print(f"[{WARNING_STYLE}]{msg}[/]")
-            return False, msg
+            if emit_console:
+                self._emit_error_message(msg, WARNING_STYLE)
+            return False, msg, None
 
         account = store.get_account(name)
         if not account:
             msg = f"Account '{name}' not found."
-            self.console.print(f"[{ERROR_STYLE}]{msg}[/]")
-            return False, msg
+            if emit_console:
+                self._emit_error_message(msg)
+            return False, msg, None
 
         api_url = account.get("api_url", "")
         api_key = account.get("api_key", "")
         if not api_url or not api_key:
             edit_cmd = f"aip accounts edit {name}"
             msg = f"Account '{name}' is missing credentials. Use `/login` or `{edit_cmd}`."
-            self.console.print(f"[{ERROR_STYLE}]{msg}[/]")
-            return False, msg
+            if emit_console:
+                self._emit_error_message(msg)
+            return False, msg, None
 
         ok, error_reason = check_connection_with_reason(api_url, api_key, abort_on_error=False)
         if not ok:
-            code, detail = self._parse_error_reason(error_reason)
-            if code == "connection_failed":
-                msg = f"Switch aborted: cannot reach {api_url}. Check URL or network."
-            elif code == "api_failed":
-                msg = f"Switch aborted: API error for '{name}'. Check credentials."
-            else:
-                detail_suffix = f": {detail}" if detail else ""
-                msg = f"Switch aborted: {code or 'Validation failed'}{detail_suffix}"
-            self.console.print(f"[{WARNING_STYLE}]{msg}[/]")
-            return False, msg
+            msg = self._format_connection_error_message(error_reason, name, api_url)
+            if emit_console:
+                self._emit_error_message(msg, WARNING_STYLE)
+            return False, msg, None
 
+        return True, "", account
+
+    def _execute_account_switch(
+        self, store: AccountStore, name: str, account: dict[str, str], invalidate_session: bool, emit_console: bool
+    ) -> tuple[bool, str]:
+        """Execute the account switch and emit success message."""
         try:
             store.set_active_account(name)
+            api_url = account.get("api_url", "")
+            api_key = account.get("api_key", "")
             masked_key = mask_api_key_display(api_key)
-            self.console.print(
-                AIPPanel(
-                    f"[{SUCCESS_STYLE}]Active account ➜ {name}[/]\nAPI URL: {api_url}\nKey: {masked_key}",
-                    title="✅ Account Switched",
-                    border_style=SUCCESS_STYLE,
+            if invalidate_session:
+                self._notify_account_switched(name)
+            if emit_console:
+                self.console.print(
+                    AIPPanel(
+                        f"[{SUCCESS_STYLE}]Active account ➜ {name}[/]\nAPI URL: {api_url}\nKey: {masked_key}",
+                        title="✅ Account Switched",
+                        border_style=SUCCESS_STYLE,
+                    )
                 )
-            )
             return True, f"Switched to '{name}'."
         except AccountStoreError as exc:
             msg = f"Failed to set active account: {exc}"
-            self.console.print(f"[{ERROR_STYLE}]{msg}[/]")
+            if emit_console:
+                self._emit_error_message(msg)
             return False, msg
         except Exception as exc:  # NOSONAR(S1045) - catch-all needed for unexpected errors
             msg = f"Unexpected error while switching to '{name}': {exc}"
-            self.console.print(f"[{ERROR_STYLE}]{msg}[/]")
+            if emit_console:
+                self._emit_error_message(msg)
             return False, msg
 
+    def _switch_account(
+        self,
+        store: AccountStore,
+        name: str,
+        env_lock: bool,
+        *,
+        emit_console: bool = True,
+        invalidate_session: bool = True,
+    ) -> tuple[bool, str]:
+        """Validate and switch active account; returns (success, message)."""
+        is_valid, error_msg, account = self._validate_account_switch(store, name, env_lock, emit_console)
+        if not is_valid:
+            return False, error_msg
+
+        if account is None:  # Defensive – should never happen, but avoid crashing in production
+            return False, "Unable to locate account after validation."
+        return self._execute_account_switch(store, name, account, invalidate_session, emit_console)
+
     @staticmethod
     def _parse_error_reason(reason: str | None) -> tuple[str, str]:
         """Parse error reason into (code, detail) to avoid fragile substring checks."""
@@ -404,8 +472,18 @@ class AccountsController:
             except Exception as exc:
                 self.console.print(f"[{WARNING_STYLE}]Account saved but could not set active: {exc}[/]")
             else:
+                self._notify_account_switched(name)
                 self._announce_active_change(store, name)
 
+    def _notify_account_switched(self, name: str | None) -> None:
+        """Best-effort notify the hosting session that the active account changed."""
+        notify = getattr(self.session, "on_account_switched", None)
+        if callable(notify):
+            try:
+                notify(name)
+            except Exception:  # pragma: no cover - best-effort callback
+                pass
+
     def _confirm_delete_prompt(self, name: str) -> bool:
         """Ask for delete confirmation; return True when confirmed."""
         self.console.print(f"[{WARNING_STYLE}]Type '{name}' to confirm deletion. This cannot be undone.[/]")

glaip_sdk/cli/slash/agent_session.py

@@ -38,7 +38,10 @@ class AgentRunSession:
         self.console = session.console
         self._agent_id = str(getattr(agent, "id", ""))
         self._agent_name = getattr(agent, "name", "") or self._agent_id
-        self._prompt_placeholder: str = "Chat with this agent here; use / for shortcuts. Alt+Enter inserts a newline."
+        self._prompt_placeholder: str = (
+            "Chat with this agent here; use / for shortcuts. "
+            "Alt+Enter inserts a newline. Ctrl+T opens the last transcript."
+        )
         self._contextual_completion_help: dict[str, str] = {
             "details": "Show this agent's configuration (+ expands prompt).",
             "help": "Display this context-aware menu.",

glaip_sdk/cli/slash/prompt.py

@@ -162,6 +162,17 @@ def _create_key_bindings(_session: SlashSession) -> Any:
         if buffer.complete_state is not None:
             buffer.cancel_completion()
 
+    @bindings.add("c-t")  # type: ignore[misc]
+    def _handle_ctrl_t_key(event: Any) -> None:  # vulture: ignore
+        """Handle Ctrl+T key - open the transcript viewer (when available)."""
+        buffer = event.app.current_buffer
+        if buffer.complete_state is not None:
+            buffer.cancel_completion()
+
+        open_viewer = getattr(_session, "open_transcript_viewer", None)
+        if callable(open_viewer):
+            open_viewer(announce=True)
+
     return bindings
 
 

glaip_sdk/cli/slash/session.py

@@ -548,7 +548,7 @@ class SlashSession:
         try:
             # Use the modern account-aware wizard directly (bypasses legacy config gating)
             _configure_interactive(account_name=None)
-            self._config_cache = None
+            self.on_account_switched()
             if self._suppress_login_layout:
                 self._welcome_rendered = False
                 self._default_actions_shown = False
@@ -1211,6 +1211,33 @@ class SlashSession:
             self._client = get_client(self.ctx)
         return self._client
 
+    def on_account_switched(self, _account_name: str | None = None) -> None:
+        """Reset any state that depends on the active account.
+
+        The active account can change via `/accounts` (or other flows that call
+        AccountStore.set_active_account). The slash session caches a configured
+        client instance, so we must invalidate it to avoid leaking the previous
+        account's API URL/key into subsequent commands like `/agents` or `/runs`.
+
+        This method clears:
+        - Client and config cache (account-specific credentials)
+        - Current agent and recent agents (agent data is account-scoped)
+        - Runs pagination state (runs are account-scoped)
+        - Active renderer and transcript ready state (UI state tied to account context)
+        - Contextual commands (may be account-specific)
+
+        These broader resets ensure a clean slate when switching accounts, preventing
+        stale data from the previous account from appearing in the new account's context.
+        """
+        self._client = None
+        self._config_cache = None
+        self._current_agent = None
+        self.recent_agents = []
+        self._runs_pagination_state.clear()
+        self.clear_active_renderer()
+        self.clear_agent_transcript_ready()
+        self.set_contextual_commands(None)
+
     def set_contextual_commands(self, commands: dict[str, str] | None, *, include_global: bool = True) -> None:
         """Set context-specific commands that should appear in completions."""
         self._contextual_commands = dict(commands or {})
@@ -1340,14 +1367,16 @@ class SlashSession:
             f"[{ACCENT_STYLE}]{agent_info['id']}[/]"
         )
         status_line = f"[{SUCCESS_STYLE}]ready[/]"
-        status_line += " · transcript ready" if transcript_status["transcript_ready"] else " · transcript pending"
+        if not transcript_status["has_transcript"]:
+            status_line += " · no transcript"
+        elif transcript_status["transcript_ready"]:
+            status_line += " · transcript ready"
+        else:
+            status_line += " · transcript pending"
         header_grid.add_row(primary_line, status_line)
 
         if agent_info["description"]:
-            description = agent_info["description"]
-            if not transcript_status["transcript_ready"]:
-                description = f"{description}  (transcript pending)"
-            header_grid.add_row(f"[dim]{description}[/dim]", "")
+            header_grid.add_row(f"[dim]{agent_info['description']}[/dim]", "")
 
         return header_grid
 

glaip_sdk/cli/slash/tui/accounts_app.py

@@ -684,6 +684,10 @@ class AccountsTextualApp(BackgroundTaskMixin, _AppBase):  # pragma: no cover - i
             return
         self.exit()
 
+    def action_app_exit(self) -> None:
+        """Exit the application regardless of focus state."""
+        self.exit()
+
     def on_button_pressed(self, event: Button.Pressed) -> None:
         """Handle filter bar buttons."""
         if event.button.id == "filter-clear":

glaip_sdk/cli/transcript/viewer.py

@@ -23,6 +23,7 @@ except Exception:  # pragma: no cover - optional dependency
 from glaip_sdk.cli.transcript.cache import suggest_filename
 from glaip_sdk.cli.utils import prompt_export_choice_questionary, questionary_safe_ask
 from glaip_sdk.utils.rendering.layout.progress import is_delegation_tool
+from glaip_sdk.utils.rendering.layout.transcript import DEFAULT_TRANSCRIPT_THEME
 from glaip_sdk.utils.rendering.viewer import (
     ViewerContext as PresenterViewerContext,
     prepare_viewer_snapshot as presenter_prepare_viewer_snapshot,
@@ -93,8 +94,9 @@ class PostRunViewer:  # pragma: no cover - interactive flows are not unit tested
         if self._view_mode == "default":
             presenter_render_post_run_view(self.console, self.ctx)
         else:
-            snapshot, state = presenter_prepare_viewer_snapshot(self.ctx, glyphs=None)
-            presenter_render_transcript_view(self.console, snapshot)
+            theme = DEFAULT_TRANSCRIPT_THEME
+            snapshot, state = presenter_prepare_viewer_snapshot(self.ctx, glyphs=None, theme=theme)
+            presenter_render_transcript_view(self.console, snapshot, theme=theme)
             presenter_render_transcript_events(self.console, state.events)
 
     # ------------------------------------------------------------------

glaip_sdk/client/tools.py

@@ -562,12 +562,14 @@ class ToolClient(BaseClient):
     ) -> Tool:
         """Find tool by name and update, or create if not found."""
         existing = self.find_tools(name)
+        name_lower = name.lower()
+        exact_matches = [tool for tool in existing if tool.name and tool.name.lower() == name_lower]
 
-        if len(existing) == 1:
+        if len(exact_matches) == 1:
             logger.info("Updating existing tool: %s", name)
-            return self._do_tool_upsert_update(existing[0].id, name, code, description, framework, **kwargs)
+            return self._do_tool_upsert_update(exact_matches[0].id, name, code, description, framework, **kwargs)
 
-        if len(existing) > 1:
+        if len(exact_matches) > 1:
             raise ValueError(f"Multiple tools found with name '{name}'")
 
         # Create new tool - code is required

glaip_sdk/registry/tool.py

@@ -160,13 +160,14 @@ class ToolRegistry(BaseRegistry["Tool"]):
             True if ref is a custom tool that needs uploading.
         """
         try:
-            from glaip_sdk.utils.tool_detection import is_langchain_tool  # noqa: PLC0415
-
-            return is_langchain_tool(ref)
+            from glaip_sdk.utils.tool_detection import (  # noqa: PLC0415
+                is_langchain_tool,
+            )
         except ImportError:
-            # Handle case where langchain_core is not available or tool_detection import fails
             return False
 
+        return is_langchain_tool(ref)
+
     def resolve(self, ref: Any) -> Tool:
         """Resolve a tool reference to a platform Tool object.
 

glaip_sdk/runner/langgraph.py

@@ -18,6 +18,7 @@ Example:
 from __future__ import annotations
 
 import asyncio
+import inspect
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any
 
@@ -30,6 +31,8 @@ from glaip_sdk.utils.a2a import A2AEventStreamProcessor
 from gllm_core.utils import LoggerManager
 
 if TYPE_CHECKING:
+    from langchain_core.messages import BaseMessage
+
     from glaip_sdk.agents.base import Agent
 
 logger = LoggerManager().get_logger(__name__)
@@ -38,6 +41,42 @@ logger = LoggerManager().get_logger(__name__)
 _event_processor = A2AEventStreamProcessor()
 
 
+def _convert_chat_history_to_messages(
+    chat_history: list[dict[str, str]] | None,
+) -> list[BaseMessage]:
+    """Convert chat history dicts to LangChain messages.
+
+    Args:
+        chat_history: List of dicts with "role" and "content" keys.
+            Supported roles: "user"/"human", "assistant"/"ai", "system".
+
+    Returns:
+        List of LangChain BaseMessage instances.
+    """
+    if not chat_history:
+        return []
+
+    from langchain_core.messages import AIMessage, HumanMessage, SystemMessage  # noqa: PLC0415
+
+    messages: list[BaseMessage] = []
+    for msg in chat_history:
+        role = msg.get("role", "").lower()
+        content = msg.get("content", "")
+
+        if role in ("user", "human"):
+            messages.append(HumanMessage(content=content))
+        elif role in ("assistant", "ai"):
+            messages.append(AIMessage(content=content))
+        elif role == "system":
+            messages.append(SystemMessage(content=content))
+        else:
+            # Default to human message for unknown roles
+            logger.warning("Unknown chat history role '%s', treating as user message", role)
+            messages.append(HumanMessage(content=content))
+
+    return messages
+
+
 @dataclass(frozen=True, slots=True)
 class LangGraphRunner(BaseRunner):
     """Runner implementation using aip-agents LangGraphReactAgent.
@@ -58,8 +97,8 @@ class LangGraphRunner(BaseRunner):
         agent: Agent,
         message: str,
         verbose: bool = False,
-        runtime_config: dict[str, Any] | None = None,  # noqa: ARG002 - Used in PR-04+
-        chat_history: (list[dict[str, str]] | None) = None,  # noqa: ARG002 - Used in PR-03
+        runtime_config: dict[str, Any] | None = None,
+        chat_history: list[dict[str, str]] | None = None,
         **kwargs: Any,
     ) -> str:
         """Execute agent synchronously and return final response text.
@@ -72,7 +111,8 @@ class LangGraphRunner(BaseRunner):
             runtime_config: Optional runtime configuration for tools, MCPs, etc.
                 Defaults to None. (Implemented in PR-04+)
             chat_history: Optional list of prior conversation messages.
-                Defaults to None. (Implemented in PR-03)
+                Each message is a dict with "role" and "content" keys.
+                Defaults to None.
             **kwargs: Additional keyword arguments passed to the backend.
 
         Returns:
@@ -85,23 +125,34 @@ class LangGraphRunner(BaseRunner):
         if not check_local_runtime_available():
             raise RuntimeError(get_local_runtime_missing_message())
 
-        return asyncio.run(
-            self._arun_internal(
-                agent=agent,
-                message=message,
-                verbose=verbose,
-                runtime_config=runtime_config,
-                **kwargs,
+        try:
+            asyncio.get_running_loop()
+        except RuntimeError:
+            pass
+        else:
+            raise RuntimeError(
+                "LangGraphRunner.run() cannot be called from a running event loop. "
+                "Use 'await LangGraphRunner.arun(...)' instead."
             )
+
+        coro = self._arun_internal(
+            agent=agent,
+            message=message,
+            verbose=verbose,
+            runtime_config=runtime_config,
+            chat_history=chat_history,
+            **kwargs,
         )
 
+        return asyncio.run(coro)
+
     async def arun(
         self,
         agent: Agent,
         message: str,
         verbose: bool = False,
         runtime_config: dict[str, Any] | None = None,
-        chat_history: (list[dict[str, str]] | None) = None,  # noqa: ARG002 - Used in PR-03
+        chat_history: list[dict[str, str]] | None = None,
         **kwargs: Any,
     ) -> str:
         """Execute agent asynchronously and return final response text.
@@ -114,7 +165,8 @@ class LangGraphRunner(BaseRunner):
             runtime_config: Optional runtime configuration for tools, MCPs, etc.
                 Defaults to None. (Implemented in PR-04+)
             chat_history: Optional list of prior conversation messages.
-                Defaults to None. (Implemented in PR-03)
+                Each message is a dict with "role" and "content" keys.
+                Defaults to None.
             **kwargs: Additional keyword arguments passed to the backend.
 
         Returns:
@@ -128,6 +180,7 @@ class LangGraphRunner(BaseRunner):
             message=message,
             verbose=verbose,
             runtime_config=runtime_config,
+            chat_history=chat_history,
             **kwargs,
         )
 
@@ -137,6 +190,7 @@ class LangGraphRunner(BaseRunner):
         message: str,
         verbose: bool = False,
         runtime_config: dict[str, Any] | None = None,
+        chat_history: list[dict[str, str]] | None = None,
         **kwargs: Any,
     ) -> str:
         """Internal async implementation of agent execution.
@@ -146,6 +200,7 @@ class LangGraphRunner(BaseRunner):
             message: The user message to send to the agent.
             verbose: If True, emit debug trace output during execution.
             runtime_config: Optional runtime configuration for tools, MCPs, etc.
+            chat_history: Optional list of prior conversation messages.
             **kwargs: Additional keyword arguments passed to the backend.
 
         Returns:
@@ -154,6 +209,16 @@ class LangGraphRunner(BaseRunner):
         # Build the local LangGraphReactAgent from the glaip_sdk Agent
         local_agent = self.build_langgraph_agent(agent, runtime_config=runtime_config)
 
+        # Convert chat history to LangChain messages for the agent
+        langchain_messages = _convert_chat_history_to_messages(chat_history)
+        if langchain_messages:
+            kwargs["messages"] = langchain_messages
+            logger.debug(
+                "Passing %d chat history messages to agent '%s'",
+                len(langchain_messages),
+                agent.name,
+            )
+
         # Collect A2AEvents from the stream and extract final response
         events: list[dict[str, Any]] = []
 
@@ -187,6 +252,9 @@ class LangGraphRunner(BaseRunner):
         from glaip_sdk.runner.tool_adapter import LangChainToolAdapter  # noqa: PLC0415
 
         # Adapt tools for local execution
+        # NOTE: CLI parity waiver - local tool execution is SDK-only for MVP.
+        # See specs/f/local-agent-runtime/plan.md: "CLI parity is explicitly deferred
+        # and will require SDK Technical Lead sign-off per constitution principle IV."
         langchain_tools: list[Any] = []
         if agent.tools:
             adapter = LangChainToolAdapter()
@@ -255,14 +323,7 @@ class LangGraphRunner(BaseRunner):
 
         sub_agent_instances = []
         for sub_agent in sub_agents:
-            if getattr(sub_agent, "_lookup_only", False):
-                agent_name = getattr(sub_agent, "name", "<unknown>")
-                raise ValueError(
-                    f"Sub-agent '{agent_name}' is not supported in local mode. "
-                    "Platform agents (from_id, from_native) cannot be used as "
-                    "sub-agents in local execution. "
-                    "Define the sub-agent locally with Agent(name=..., instruction=...) instead."
-                )
+            self._validate_sub_agent_for_local_mode(sub_agent)
             sub_agent_instances.append(self.build_langgraph_agent(sub_agent, runtime_config))
         return sub_agent_instances
 
@@ -286,16 +347,12 @@ class LangGraphRunner(BaseRunner):
 
         mcp_adapter = LangChainMCPAdapter()
         base_mcp_configs = mcp_adapter.adapt_mcps(agent.mcps)
-        logger.debug("Base MCP configs from adapter: %s", base_mcp_configs)
 
         # Apply merged mcp_configs overrides (agent definition + runtime)
-        logger.debug("Merged mcp_configs to apply: %s", merged_mcp_configs)
         if merged_mcp_configs:
             base_mcp_configs = self._apply_runtime_mcp_configs(base_mcp_configs, merged_mcp_configs)
-            logger.debug("MCP configs after override: %s", base_mcp_configs)
 
         if base_mcp_configs:
-            logger.info("MCP configs being sent to aip-agents: %s", base_mcp_configs)
             local_agent.add_mcp_server(base_mcp_configs)
             logger.debug(
                 "Registered %d MCP server(s) for agent '%s'",
@@ -361,6 +418,7 @@ class LangGraphRunner(BaseRunner):
         Returns:
             Agent-specific config dict, or empty dict if not found.
         """
+        from glaip_sdk.utils.resource_refs import is_uuid  # noqa: PLC0415
         from glaip_sdk.utils.runtime_config import get_name_from_key  # noqa: PLC0415
 
         # Reserved keys at the top level
@@ -371,6 +429,14 @@ class LangGraphRunner(BaseRunner):
             if key in reserved_keys:
                 continue  # Skip global configs
 
+            if isinstance(key, str) and is_uuid(key):
+                logger.warning(
+                    "UUID agent override key '%s' is not supported in local mode; skipping. "
+                    "Use agent name string or Agent instance as the key instead.",
+                    key,
+                )
+                continue
+
             # Check if this key matches the agent
             try:
                 key_name = get_name_from_key(key)
@@ -579,6 +645,49 @@ class LangGraphRunner(BaseRunner):
 
         return merged
 
+    def _validate_sub_agent_for_local_mode(self, sub_agent: Any) -> None:
+        """Validate that a sub-agent reference is supported for local execution.
+
+        Args:
+            sub_agent: The sub-agent reference to validate.
+
+        Raises:
+            ValueError: If the sub-agent is not supported in local mode.
+        """
+        # String references are allowed by SDK API but not for local mode
+        if isinstance(sub_agent, str):
+            raise ValueError(
+                f"Sub-agent '{sub_agent}' is a string reference and cannot be used in local mode. "
+                "String sub-agent references are only supported for server execution. "
+                "For local mode, define the sub-agent with Agent(name=..., instruction=...)."
+            )
+
+        # Validate sub-agent is not a class
+        if inspect.isclass(sub_agent):
+            raise ValueError(
+                f"Sub-agent '{sub_agent.__name__}' is a class, not an instance. "
+                "Local mode requires Agent INSTANCES. "
+                "Did you forget to instantiate it? e.g., Agent(...), not Agent"
+            )
+
+        # Validate sub-agent is an Agent-like object (has required attributes)
+        if not hasattr(sub_agent, "name") or not hasattr(sub_agent, "instruction"):
+            raise ValueError(
+                f"Sub-agent {type(sub_agent).__name__} is not supported in local mode. "
+                "Local mode requires Agent instances with 'name' and 'instruction' attributes. "
+                "Define the sub-agent with Agent(name=..., instruction=...)."
+            )
+
+        # Validate sub-agent is not platform-only (from_id, from_native)
+        if getattr(sub_agent, "_lookup_only", False):
+            agent_name = getattr(sub_agent, "name", "<unknown>")
+            raise ValueError(
+                f"Sub-agent '{agent_name}' is not supported in local mode. "
+                "Platform agents (from_id, from_native) cannot be used as "
+                "sub-agents in local execution. "
+                "Define the sub-agent locally with Agent(name=..., instruction=...) instead."
+            )
+
     def _log_event(self, event: dict[str, Any]) -> None:
         """Log an A2AEvent for verbose debug output.
 

glaip_sdk/runner/mcp_adapter/langchain_mcp_adapter.py

@@ -9,10 +9,9 @@ Authors:
 
 from typing import Any
 
-from gllm_core.utils import LoggerManager
-
 from glaip_sdk.runner.mcp_adapter.base_mcp_adapter import BaseMCPAdapter
 from glaip_sdk.runner.mcp_adapter.mcp_config_builder import MCPConfigBuilder
+from gllm_core.utils import LoggerManager
 
 logger = LoggerManager().get_logger(__name__)
 
@@ -115,17 +114,117 @@ class LangChainMCPAdapter(BaseMCPAdapter):
         if "server_url" in config and "url" not in config:
             config["url"] = config.pop("server_url")
 
+        self._validate_converted_config(
+            mcp_name=mcp.name,
+            transport=mcp.transport,
+            config=config,
+        )
+
         # Convert authentication to headers using MCPConfigBuilder
+        # Merge with existing headers (auth headers take precedence for conflicts)
         if hasattr(mcp, "authentication") and mcp.authentication:
-            headers = MCPConfigBuilder.build_headers_from_auth(mcp.authentication)
-            if headers:
-                config["headers"] = headers
+            auth_headers = MCPConfigBuilder.build_headers_from_auth(mcp.authentication)
+            if auth_headers:
+                existing_headers = config.get("headers", {})
+                config["headers"] = {**existing_headers, **auth_headers}
             else:
                 logger.warning("Failed to build headers from authentication for MCP '%s'", mcp.name)
 
         logger.debug("Converted MCP '%s' with transport '%s'", mcp.name, mcp.transport)
         return config
 
+    def _validate_converted_config(self, mcp_name: str, transport: str, config: dict[str, Any]) -> None:
+        """Validate converted MCP config matches aip-agents schema expectations.
+
+        This method performs transport-specific validation after the glaip-sdk MCP
+        has been converted into the `aip-agents` `mcp_config` dictionary.
+
+        Args:
+            mcp_name: The MCP server name.
+            transport: The MCP transport type.
+            config: The converted MCP configuration dictionary.
+
+        Raises:
+            ValueError: If the configuration is invalid for the chosen transport.
+        """
+        self._validate_transport_config(mcp_name, transport)
+        if transport in ("http", "sse"):
+            self._validate_http_sse_config(
+                mcp_name=mcp_name,
+                transport=transport,
+                config=config,
+            )
+            return
+        if transport == "stdio":
+            self._validate_stdio_config(
+                mcp_name=mcp_name,
+                config=config,
+            )
+
+    def _validate_transport_config(self, mcp_name: str, transport: str) -> None:
+        """Validate that the MCP transport is supported by local mode.
+
+        Args:
+            mcp_name: The MCP server name.
+            transport: The MCP transport type.
+
+        Raises:
+            ValueError: If the transport is not one of 'http', 'sse', or 'stdio'.
+        """
+        if transport not in ("http", "sse", "stdio"):
+            raise ValueError(
+                f"Invalid MCP config for '{mcp_name}': transport must be one of "
+                f"'http', 'sse', or 'stdio'. Got: {transport!r}"
+            )
+
+    def _validate_http_sse_config(self, mcp_name: str, transport: str, config: dict[str, Any]) -> None:
+        """Validate http/sse config has a usable URL.
+
+        Args:
+            mcp_name: The MCP server name.
+            transport: The MCP transport type ('http' or 'sse').
+            config: The converted MCP configuration dictionary.
+
+        Raises:
+            ValueError: If url is missing/empty or does not use http(s) scheme.
+        """
+        url = config.get("url")
+        if not isinstance(url, str) or not url:
+            raise ValueError(
+                f"Invalid MCP config for '{mcp_name}': transport='{transport}' "
+                "requires config['url'] as a non-empty string."
+            )
+
+        if not (url.startswith("http://") or url.startswith("https://")):
+            raise ValueError(
+                f"Invalid MCP config for '{mcp_name}': config['url'] must start with "
+                f"'http://' or 'https://'. Got: {url!r}"
+            )
+
+    def _validate_stdio_config(self, mcp_name: str, config: dict[str, Any]) -> None:
+        """Validate stdio config has a usable command and optional args list.
+
+        Args:
+            mcp_name: The MCP server name.
+            config: The converted MCP configuration dictionary.
+
+        Raises:
+            ValueError: If command is missing/empty or args is not a list of strings.
+        """
+        command = config.get("command")
+        if not isinstance(command, str) or not command:
+            raise ValueError(
+                f"Invalid MCP config for '{mcp_name}': transport='stdio' "
+                "requires config['command'] as a non-empty string."
+            )
+
+        args = config.get("args")
+        if args is not None and (not isinstance(args, list) or any(not isinstance(x, str) for x in args)):
+            raise ValueError(
+                f"Invalid MCP config for '{mcp_name}': transport='stdio' expects "
+                "config['args'] to be a list[str] if provided."
+            )
+
     def _is_platform_mcp(self, ref: Any) -> bool:
         """Check if ref is platform-specific (not supported locally)."""
         # MCP.from_native() or MCP.from_id() instances

glaip_sdk/runner/tool_adapter/langchain_tool_adapter.py

@@ -9,12 +9,14 @@ Authors:
 
 from typing import Any
 
-from gllm_core.utils import LoggerManager
-
 from glaip_sdk.runner.tool_adapter.base_tool_adapter import BaseToolAdapter
+from gllm_core.utils import LoggerManager
 
 logger = LoggerManager().get_logger(__name__)
 
+# Constant for unknown tool name placeholder
+_UNKNOWN_TOOL_NAME = "<unknown>"
+
 
 class LangChainToolAdapter(BaseToolAdapter):
     """Adapts glaip-sdk tools to LangChain BaseTool format for aip-agents.
@@ -81,6 +83,15 @@ class LangChainToolAdapter(BaseToolAdapter):
             "Local mode only supports LangChain BaseTool classes/instances."
         )
 
+    def _has_explicit_attr(self, ref: Any, attr: str) -> bool:
+        """Check if attribute is explicitly set on the object.
+
+        This avoids false positives from objects like MagicMock, where hasattr()
+        can return True even if the attribute was never set.
+        """
+        ref_dict = getattr(ref, "__dict__", None)
+        return isinstance(ref_dict, dict) and attr in ref_dict
+
     def _is_tool_wrapper(self, ref: Any) -> bool:
         """Check if ref is a Tool.from_langchain() wrapper.
 
@@ -90,7 +101,13 @@ class LangChainToolAdapter(BaseToolAdapter):
         Returns:
             True if ref is a Tool.from_langchain() wrapper.
         """
-        return hasattr(ref, "langchain_tool") and hasattr(ref, "id") and hasattr(ref, "name")
+        if self._has_explicit_attr(ref, "langchain_tool") and hasattr(ref, "id") and hasattr(ref, "name"):
+            return True
+
+        if self._has_explicit_attr(ref, "tool_class"):
+            return getattr(ref, "tool_class", None) is not None
+
+        return False
 
     def _extract_from_wrapper(self, wrapper: Any) -> Any:
         """Extract underlying LangChain tool from Tool.from_langchain().
@@ -100,8 +117,29 @@ class LangChainToolAdapter(BaseToolAdapter):
 
         Returns:
             LangChain BaseTool instance.
+
+        Raises:
+            ValueError: If the wrapper's underlying tool is not a valid LangChain tool.
         """
-        langchain_tool = wrapper.langchain_tool
+        langchain_tool = getattr(wrapper, "langchain_tool", None)
+        if langchain_tool is None:
+            langchain_tool = getattr(wrapper, "tool_class", None)
+
+        # Validate the extracted object is a valid LangChain tool
+        if langchain_tool is None:
+            wrapper_name = getattr(wrapper, "name", _UNKNOWN_TOOL_NAME)
+            raise ValueError(
+                f"Tool wrapper '{wrapper_name}' does not contain a valid LangChain tool. "
+                "Ensure Tool.from_langchain() was called with a LangChain BaseTool class or instance."
+            )
+
+        # Validate it's actually a LangChain tool (class or instance)
+        if not self._is_langchain_tool(langchain_tool):
+            wrapper_name = getattr(wrapper, "name", _UNKNOWN_TOOL_NAME)
+            raise ValueError(
+                f"Tool wrapper '{wrapper_name}' contains an invalid tool type: {type(langchain_tool)}. "
+                "Expected a LangChain BaseTool class or instance."
+            )
 
         # If it's a class, instantiate it
         if isinstance(langchain_tool, type):
@@ -109,7 +147,7 @@ class LangChainToolAdapter(BaseToolAdapter):
 
         logger.debug(
             "Extracted LangChain tool from wrapper: %s",
-            getattr(langchain_tool, "name", "<unknown>"),
+            getattr(langchain_tool, "name", _UNKNOWN_TOOL_NAME),
         )
         return langchain_tool
 
@@ -155,8 +193,10 @@ class LangChainToolAdapter(BaseToolAdapter):
             return True
 
         # Tool.from_native() instances
-        if hasattr(ref, "id") and hasattr(ref, "name") and not hasattr(ref, "langchain_tool"):
-            return True
+        if hasattr(ref, "id") and hasattr(ref, "name") and not self._has_explicit_attr(ref, "langchain_tool"):
+            tool_class = getattr(ref, "tool_class", None) if self._has_explicit_attr(ref, "tool_class") else None
+            if tool_class is None:
+                return True
 
         return False
 
@@ -173,5 +213,7 @@ class LangChainToolAdapter(BaseToolAdapter):
             get_local_mode_not_supported_for_tool_message,
         )
 
-        tool_name = ref if isinstance(ref, str) else getattr(ref, "name", "<unknown>")
+        tool_name = ref if isinstance(ref, str) else getattr(ref, "name", None)
+        if tool_name is None:
+            tool_name = getattr(getattr(ref, "tool_class", None), "__name__", _UNKNOWN_TOOL_NAME)
         return get_local_mode_not_supported_for_tool_message(tool_name)

glaip_sdk/utils/runtime_config.py

@@ -315,7 +315,7 @@ def normalize_runtime_config_keys(
 
 
 def _get_name_from_class(cls: type) -> str:
-    """Extract name from a class, handling Pydantic models.
+    """Extract name from a class, handling Pydantic models and @property descriptors.
 
     Args:
         cls: The class to extract name from.
@@ -323,9 +323,10 @@ def _get_name_from_class(cls: type) -> str:
     Returns:
         The resolved name string.
     """
-    # Try class-level name attribute first
+    # Try class-level name attribute first, but guard against @property descriptors
+    # When a class has @property name, getattr returns the property object, not a string
     class_name = getattr(cls, "name", None)
-    if class_name:
+    if isinstance(class_name, str) and class_name:
         return class_name
 
     # For Pydantic models, check model_fields for default value
@@ -355,24 +356,26 @@ def get_name_from_key(key: object) -> str | None:
     Raises:
         ValueError: If the key cannot be resolved to a valid name.
     """
-    # Instance with name attribute
-    if hasattr(key, "name"):
-        name = getattr(key, "name", None)
-        if name:
-            return name
-        raise ValueError(f"Unable to resolve config key: {key!r}")
-
-    # Class type (not instance)
+    # Class type (not instance) - must check BEFORE hasattr("name")
+    # because classes with @property name will have hasattr return True
+    # but getattr returns the property descriptor, not a string
     if isinstance(key, type):
         return _get_name_from_class(key)
 
-    # String key
+    # String key - check early to avoid attribute access
     if isinstance(key, str):
         if is_uuid(key):
             logger.warning("UUID '%s' not supported in local mode, skipping", key)
             return None
         return key
 
+    # Instance with name attribute
+    if hasattr(key, "name"):
+        name = getattr(key, "name", None)
+        # Guard against @property that returns non-string (e.g., descriptor)
+        if isinstance(name, str) and name:
+            return name
+
     raise ValueError(f"Unable to resolve config key: {key!r}")
 
 

{glaip_sdk-0.6.5b9.dist-info → glaip_sdk-0.6.8b1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: glaip-sdk
-Version: 0.6.5b9
+Version: 0.6.8b1
 Summary: Python SDK for GL AIP (GDP Labs AI Agent Package) - Simplified CLI Design
 License: MIT
 Author: Raymond Christopher
@@ -13,9 +13,9 @@ Classifier: Programming Language :: Python :: 3.12
 Provides-Extra: dev
 Provides-Extra: memory
 Provides-Extra: privacy
-Requires-Dist: aip-agents-binary (==0.5.0b2)
-Requires-Dist: aip-agents[memory] (==0.5.0b2) ; (python_version >= "3.11" and python_version < "3.13") and (extra == "memory")
-Requires-Dist: aip-agents[privacy] (==0.5.0b2) ; (python_version >= "3.11" and python_version < "3.13") and (extra == "privacy")
+Requires-Dist: aip-agents-binary (>=0.5.1)
+Requires-Dist: aip-agents[memory] (>=0.5.1) ; (python_version >= "3.11" and python_version < "3.13") and (extra == "memory")
+Requires-Dist: aip-agents[privacy] (>=0.5.1) ; (python_version >= "3.11" and python_version < "3.13") and (extra == "privacy")
 Requires-Dist: click (>=8.2.0,<8.3.0)
 Requires-Dist: gllm-core-binary (>=0.1.0)
 Requires-Dist: gllm-tools-binary (>=0.1.3)

{glaip_sdk-0.6.5b9.dist-info → glaip_sdk-0.6.8b1.dist-info}/RECORD

@@ -1,7 +1,7 @@
 glaip_sdk/__init__.py,sha256=0PAFfodqAEdggIiV1Es_JryDokZrhYLFFIXosqdguJU,420
 glaip_sdk/_version.py,sha256=5CHGCxx_36fgmMWuEx6jJ2CzzM-i9eBFyQWFwBi23XE,2259
 glaip_sdk/agents/__init__.py,sha256=VfYov56edbWuySXFEbWJ_jLXgwnFzPk1KB-9-mfsUCc,776
-glaip_sdk/agents/base.py,sha256=xCu4vZ2EOXbpsY38Cbebdqz-7ZNmZK9_wo8DxyZh7eA,39577
+glaip_sdk/agents/base.py,sha256=5ZX7bVf64AB1DodBriHrzJg5QYvpTai_vYk6Br0JmAU,42338
 glaip_sdk/branding.py,sha256=tLqYCIHMkUf8p2smpuAGNptwaKUN38G4mlh0A0DOl_w,7823
 glaip_sdk/cli/__init__.py,sha256=xCCfuF1Yc7mpCDcfhHZTX0vizvtrDSLeT8MJ3V7m5A0,156
 glaip_sdk/cli/account_store.py,sha256=TK4iTV93Q1uD9mCY_2ZMT6EazHKU2jX0qhgWfEM4V-4,18459
@@ -11,7 +11,7 @@ glaip_sdk/cli/commands/__init__.py,sha256=6Z3ASXDut0lAbUX_umBFtxPzzFyqoiZfVeTahT
 glaip_sdk/cli/commands/accounts.py,sha256=J89chwJWWpEv6TBXaGPUJH-aLrM9Ymxp4jywp5YUUEo,24685
 glaip_sdk/cli/commands/agents.py,sha256=WCOzllyh_Znwlju5camT4vE6OeRJbsAmjWwcyiAqWs4,48429
 glaip_sdk/cli/commands/common_config.py,sha256=chCa0B5t6JER-pGPzItUK7fk_qQgTwf7bIRU004PrUI,3731
-glaip_sdk/cli/commands/configure.py,sha256=95PQiJnpvsdH02v_tLVANd64qAJJnZKlhNe4tpfWIS4,30262
+glaip_sdk/cli/commands/configure.py,sha256=Y3ST1I33rXqlLvUyhKFOl9JUjDe01QCrL1dzOjO1E-c,30304
 glaip_sdk/cli/commands/mcps.py,sha256=tttqQnfM89iI9Pm94u8YRhiHMQNYNouecFX0brsT4cQ,42551
 glaip_sdk/cli/commands/models.py,sha256=vfcGprK5CHprQ0CNpNzQlNNTELvdgKC7JxTG_ijOwmE,2009
 glaip_sdk/cli/commands/tools.py,sha256=_VBqG-vIjnn-gqvDlSTvcU7_F4N3ANGGKEECcQVR-BM,18430
@@ -37,15 +37,15 @@ glaip_sdk/cli/parsers/json_input.py,sha256=kxoxeIlgfsaH2jhe6apZAgSxAtwlpSINLTMRs
 glaip_sdk/cli/resolution.py,sha256=K-VaEHm9SYY_qfb9538VNHykL4_2N6F8iQqI1zMx_64,2402
 glaip_sdk/cli/rich_helpers.py,sha256=kO47N8e506rxrN6Oc9mbAWN3Qb536oQPWZy1s9A616g,819
 glaip_sdk/cli/slash/__init__.py,sha256=J9TPL2UcNTkW8eifG6nRmAEGHhyEgdYMYk4cHaaObC0,386
-glaip_sdk/cli/slash/accounts_controller.py,sha256=BDKaEfVbMh1B2T4GW3FF5hJo0SCe9_Pmy8vvyXtI9LY,21562
+glaip_sdk/cli/slash/accounts_controller.py,sha256=-7v_4nTAVCqXySbOLtTfMpUpsqCzDTWmZYkBU880AzI,24803
 glaip_sdk/cli/slash/accounts_shared.py,sha256=Mq5HxlI0YsVEQ0KKISWvyBZhzOFFWCzwRbhF5xwvUbM,2626
-glaip_sdk/cli/slash/agent_session.py,sha256=9r1xNRk5mk6rfJXV6KIf2Yo4B4hjknimd9fkxH1LO3c,11304
-glaip_sdk/cli/slash/prompt.py,sha256=2urqR3QqN3O09lHmKKSEbhsIdlS4B7hm9O8AP_VwCSU,8034
+glaip_sdk/cli/slash/agent_session.py,sha256=ZK51zrwhFtun26Lu3a70Kcp3VFh0jwu37crWDKx7Ivk,11377
+glaip_sdk/cli/slash/prompt.py,sha256=q4f1c2zr7ZMUeO6AgOBF2Nz4qgMOXrVPt6WzPRQMbAM,8501
 glaip_sdk/cli/slash/remote_runs_controller.py,sha256=Ok6CezIeF1CPGQ8-QN3TRx5kGGEACOrgyPwH_BRRCyI,21354
-glaip_sdk/cli/slash/session.py,sha256=8pfO21vAbpxWnE71fthXXsR0TijYBDDhHR-8LFFapUs,63028
+glaip_sdk/cli/slash/session.py,sha256=JieIjUCTMW350LDqdSOdfPP8U0OJSmRYvqPBbddO2bw,64333
 glaip_sdk/cli/slash/tui/__init__.py,sha256=ljBAeAFY2qNDkbJrZh5NgXxjwUlsv9-UxgKNIv0AF1Q,274
 glaip_sdk/cli/slash/tui/accounts.tcss,sha256=xuQjQ0tBM08K1DUv6lI5Sfu1zgZzQxg60c9-RlEWB4s,1160
-glaip_sdk/cli/slash/tui/accounts_app.py,sha256=dE0w10MSGPgjE7YQl8LzF1pSYu6LKX-L6eYMFOM2530,33593
+glaip_sdk/cli/slash/tui/accounts_app.py,sha256=QDaOpVStS6Z51tfXcS8GRRjTrVfMO26-guHepqysU9k,33715
 glaip_sdk/cli/slash/tui/background_tasks.py,sha256=SAe1mV2vXB3mJcSGhelU950vf8Lifjhws9iomyIVFKw,2422
 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
@@ -55,7 +55,7 @@ glaip_sdk/cli/transcript/capture.py,sha256=t8j_62cC6rhb51oCluZd17N04vcXqyjkhPRcR
 glaip_sdk/cli/transcript/export.py,sha256=reCvrZVzli8_LzYe5ZNdaa-MwZ1ov2RjnDzKZWr_6-E,1117
 glaip_sdk/cli/transcript/history.py,sha256=2FBjawxP8CX9gRPMUMP8bDjG50BGM2j2zk6IfHvAMH4,26211
 glaip_sdk/cli/transcript/launcher.py,sha256=z5ivkPXDQJpATIqtRLUK8jH3p3WIZ72PvOPqYRDMJvw,2327
-glaip_sdk/cli/transcript/viewer.py,sha256=ar1SzRkhKIf3_DgFz1EG1RZGDmd2w2wogAe038DLL_M,13037
+glaip_sdk/cli/transcript/viewer.py,sha256=HKL3U-FrhluKSmxLdE_kTbdTalG-LCE0wu1MXsf22Ao,13189
 glaip_sdk/cli/update_notifier.py,sha256=FnTjzS8YT94RmP6c5aU_XNIyRi7FRHvAskMy-VJikl8,10064
 glaip_sdk/cli/utils.py,sha256=iemmKkpPndoZFBasoVqV7QArplchtr08yYWLA2efMzg,11996
 glaip_sdk/cli/validators.py,sha256=d-kq4y7HWMo6Gc7wLXWUsCt8JwFvJX_roZqRm1Nko1I,5622
@@ -68,7 +68,7 @@ glaip_sdk/client/main.py,sha256=RTREAOgGouYm4lFKkpNBQ9dmxalnBsIpSSaQLWVFSmU,9054
 glaip_sdk/client/mcps.py,sha256=gFRuLOGeh6ieIhR4PeD6yNVT6NhvUMTqPq9iuu1vkAY,13019
 glaip_sdk/client/run_rendering.py,sha256=ubBO-NzyZoYRELNwxVvrQFRGQVJCuLfqqJNiXrBZDoQ,14223
 glaip_sdk/client/shared.py,sha256=esHlsR0LEfL-pFDaWebQjKKOLl09jsRY-2pllBUn4nU,522
-glaip_sdk/client/tools.py,sha256=RR7345wECqPtofDXPW12VOnLtus554tXleL0YHQy82U,22435
+glaip_sdk/client/tools.py,sha256=kK0rBwX1e_5AlGQRjlO6rNz6gDlohhXWdlxN9AwotdE,22585
 glaip_sdk/client/validators.py,sha256=ioF9VCs-LG2yLkaRDd7Hff74lojDZZ0_Q3CiLbdm1RY,8381
 glaip_sdk/config/constants.py,sha256=Y03c6op0e7K0jTQ8bmWXhWAqsnjWxkAhWniq8Z0iEKY,1081
 glaip_sdk/exceptions.py,sha256=iAChFClkytXRBLP0vZq1_YjoZxA9i4m4bW1gDLiGR1g,2321
@@ -87,19 +87,19 @@ 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=Aq6eryE9hOF9XFnjaBwfnrQgii5uyMdMkLaqm9D9BEk,7765
+glaip_sdk/registry/tool.py,sha256=rxrVxnO_VwO6E5kccqxxEUC337J9qbKpje-Gwl5a3sY,7699
 glaip_sdk/rich_components.py,sha256=44Z0V1ZQleVh9gUDGwRR5mriiYFnVGOhm7fFxZYbP8c,4052
 glaip_sdk/runner/__init__.py,sha256=8RrngoGfpF8x9X27RPdX4gJjch75ZvhtVt_6UV0ULLQ,1615
 glaip_sdk/runner/base.py,sha256=KIjcSAyDCP9_mn2H4rXR5gu1FZlwD9pe0gkTBmr6Yi4,2663
 glaip_sdk/runner/deps.py,sha256=3ZDWyvWu4LFJOGHd18tv3VzVo8NY5gb1VeZIelMknyI,3934
-glaip_sdk/runner/langgraph.py,sha256=OPuD44EERJgrlQoM8iGEgGV5pA7e-WeCPHMSe4znYPs,21840
+glaip_sdk/runner/langgraph.py,sha256=N9jhuCI-7dS6gzrsKzG6xT3CGWKuo7GEpEwfszgORVo,26050
 glaip_sdk/runner/mcp_adapter/__init__.py,sha256=Rdttfg3N6kg3-DaTCKqaGXKByZyBt0Mwf6FV8s_5kI8,462
 glaip_sdk/runner/mcp_adapter/base_mcp_adapter.py,sha256=ic56fKgb3zgVZZQm3ClWUZi7pE1t4EVq8mOg6AM6hdA,1374
-glaip_sdk/runner/mcp_adapter/langchain_mcp_adapter.py,sha256=88moaeTDW7KPxu6qh8mK4pr6oqpOLKLgXX66gFB-5J0,5715
+glaip_sdk/runner/mcp_adapter/langchain_mcp_adapter.py,sha256=b58GuadPz7q7aXoJyTYs0eeJ_oqp-wLR1tcr_5cbV1s,9723
 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=tmRYyPhih0a4_8c7Cg7ariYP2AEtHW69TRxqukwa2Ko,5438
+glaip_sdk/runner/tool_adapter/langchain_tool_adapter.py,sha256=goSSDOpubuplsKpfemlbesf_bZBdpDKSTqLILvApcjA,7438
 glaip_sdk/tools/__init__.py,sha256=rhGzEqQFCzeMrxmikBuNrMz4PyYczwic28boDKVmoHs,585
 glaip_sdk/tools/base.py,sha256=bvumLJ-DiQTmuYKgq2yCnlwrTZ9nYXpOwWU0e1vWR5g,15185
 glaip_sdk/utils/__init__.py,sha256=ntohV7cxlY2Yksi2nFuFm_Mg2XVJbBbSJVRej7Mi9YE,2770
@@ -148,12 +148,12 @@ glaip_sdk/utils/rendering/viewer/__init__.py,sha256=XrxmE2cMAozqrzo1jtDFm8HqNtvD
 glaip_sdk/utils/rendering/viewer/presenter.py,sha256=mlLMTjnyeyPVtsyrAbz1BJu9lFGQSlS-voZ-_Cuugv0,5725
 glaip_sdk/utils/resource_refs.py,sha256=vF34kyAtFBLnaKnQVrsr2st1JiSxVbIZ4yq0DelJvCI,5966
 glaip_sdk/utils/run_renderer.py,sha256=d_VMI6LbvHPUUeRmGqh5wK_lHqDEIAcym2iqpbtDad0,1365
-glaip_sdk/utils/runtime_config.py,sha256=SPvc2qF7qGio745kMwOOtzXY1-pHI3Vi3BJHcHFhwiE,13634
+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=3VKqs1UfNGWSobgRXohBKP7mMMzdUW3SU0bJQ1uxOgw,4872
 glaip_sdk/utils/tool_detection.py,sha256=g410GNug_PhLye8rd9UU-LVFIKq3jHPbmSItEkLxPTc,807
 glaip_sdk/utils/validation.py,sha256=hB_k3lvHdIFUiSwHStrC0Eqnhx0OG2UvwqASeem0HuQ,6859
-glaip_sdk-0.6.5b9.dist-info/METADATA,sha256=B-iwONbryPtYPCW-0YHWqgSu_9FBuQBhjcFzCiUslYc,7927
-glaip_sdk-0.6.5b9.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-glaip_sdk-0.6.5b9.dist-info/entry_points.txt,sha256=EGs8NO8J1fdFMWA3CsF7sKBEvtHb_fujdCoNPhfMouE,47
-glaip_sdk-0.6.5b9.dist-info/RECORD,,
+glaip_sdk-0.6.8b1.dist-info/METADATA,sha256=mwvQlQevc5j99zjtialgGWO62muor8JP13GA0VwRCt4,7921
+glaip_sdk-0.6.8b1.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+glaip_sdk-0.6.8b1.dist-info/entry_points.txt,sha256=EGs8NO8J1fdFMWA3CsF7sKBEvtHb_fujdCoNPhfMouE,47
+glaip_sdk-0.6.8b1.dist-info/RECORD,,