glaip-sdk 0.6.5b9__py3-none-any.whl → 0.6.6__py3-none-any.whl

glaip_sdk/agents/base.py

@@ -50,11 +50,6 @@ from pathlib import Path
 from typing import TYPE_CHECKING, Any
 
 from glaip_sdk.registry import get_agent_registry, get_mcp_registry, get_tool_registry
-from glaip_sdk.runner import get_default_runner
-from glaip_sdk.runner.deps import (
-    check_local_runtime_available,
-    get_local_runtime_missing_message,
-)
 from glaip_sdk.utils.discovery import find_agent
 from glaip_sdk.utils.resource_refs import is_uuid
 from glaip_sdk.utils.runtime_config import normalize_runtime_config_keys
@@ -898,20 +893,13 @@ class Agent:
         message: str,
         verbose: bool = False,
         runtime_config: dict[str, Any] | None = None,
-        chat_history: list[dict[str, str]] | None = None,
         **kwargs: Any,
     ) -> str:
         """Run the agent synchronously with a message.
 
-        Supports two execution modes:
-        - **Server-backed**: When the agent is deployed (has an ID), execution
-          happens via the AIP backend server.
-        - **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. Defaults to False.
+            verbose: If True, print streaming output to console.
             runtime_config: Optional runtime configuration for tools, MCPs, and agents.
                 Keys can be SDK objects, UUIDs, or names. Example:
                 {
@@ -919,43 +907,19 @@ 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.
 
         Returns:
             The agent's response as a string.
 
         Raises:
-            ValueError: If the agent is not deployed and local runtime is not available.
-            RuntimeError: If server-backed execution fails due to client issues.
+            ValueError: If the agent hasn't been deployed yet.
+            RuntimeError: If client is not available.
         """
-        # 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
-            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()}")
+        agent_client, call_kwargs = self._prepare_run_kwargs(
+            message, verbose, runtime_config or kwargs.get("runtime_config"), **kwargs
+        )
+        return agent_client.run_agent(**call_kwargs)
 
     async def arun(
         self,

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,12 +160,19 @@ 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
+            from langchain_core.tools import BaseTool  # noqa: PLC0415
 
-            return is_langchain_tool(ref)
+            # LangChain BaseTool class
+            if isinstance(ref, type) and issubclass(ref, BaseTool):
+                return True
+
+            # LangChain BaseTool instance
+            if isinstance(ref, BaseTool):
+                return True
         except ImportError:
-            # Handle case where langchain_core is not available or tool_detection import fails
-            return False
+            pass
+
+        return False
 
     def resolve(self, ref: Any) -> Tool:
         """Resolve a tool reference to a platform Tool object.

glaip_sdk/utils/runtime_config.py

@@ -304,119 +304,3 @@ def normalize_runtime_config_keys(
             logger.warning("Unknown field '%s' in runtime_config, ignoring", field)
 
     return result
-
-
-# =============================================================================
-# LOCAL MODE UTILITIES
-# =============================================================================
-# The functions below are for local execution mode where resources are NOT
-# deployed and have no UUIDs. They resolve keys to names (not IDs).
-# =============================================================================
-
-
-def _get_name_from_class(cls: type) -> str:
-    """Extract name from a class, handling Pydantic models.
-
-    Args:
-        cls: The class to extract name from.
-
-    Returns:
-        The resolved name string.
-    """
-    # Try class-level name attribute first
-    class_name = getattr(cls, "name", None)
-    if class_name:
-        return class_name
-
-    # For Pydantic models, check model_fields for default value
-    model_fields = getattr(cls, "model_fields", None)
-    if model_fields and "name" in model_fields:
-        field_info = model_fields["name"]
-        default = getattr(field_info, "default", None)
-        if default and isinstance(default, str):
-            return default
-
-    # Fallback to class __name__
-    return cls.__name__
-
-
-def get_name_from_key(key: object) -> str | None:
-    """Resolve config key to name for local mode (no registry needed).
-
-    Supports instances, classes, and string names. UUID strings are not
-    supported in local mode and return None with a warning.
-
-    Args:
-        key: Tool, MCP, or Agent instance/class/string.
-
-    Returns:
-        The resolved name string, or None if UUID (not applicable locally).
-
-    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)
-    if isinstance(key, type):
-        return _get_name_from_class(key)
-
-    # String key
-    if isinstance(key, str):
-        if is_uuid(key):
-            logger.warning("UUID '%s' not supported in local mode, skipping", key)
-            return None
-        return key
-
-    raise ValueError(f"Unable to resolve config key: {key!r}")
-
-
-def normalize_local_config_keys(config: dict[object, object]) -> dict[str, object]:
-    """Normalize all keys in a config dict to names for local mode.
-
-    Converts instance/class/string keys to string names without using
-    registry. UUID keys are skipped with a warning.
-
-    Args:
-        config: Dict with instance/class/string keys and any values.
-
-    Returns:
-        Dict with string name keys only. UUID keys are omitted.
-    """
-    if not config:
-        return {}
-
-    result: dict[str, object] = {}
-    for key, value in config.items():
-        name = get_name_from_key(key)
-        if name is not None:
-            result[name] = value
-    return result
-
-
-def merge_configs(*configs: dict | None) -> dict:
-    """Merge multiple config dicts with priority ordering.
-
-    Later configs override earlier ones for the same key. None configs
-    are skipped gracefully.
-
-    Args:
-        *configs: Config dicts in priority order (lowest priority first).
-
-    Returns:
-        Merged config dict with later values overriding earlier ones.
-
-    Example:
-        >>> merge_configs({"a": 1}, {"a": 2, "b": 3})
-        {"a": 2, "b": 3}
-    """
-    result: dict = {}
-    for config in configs:
-        if config:
-            result.update(config)
-    return result

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

@@ -1,41 +1,27 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.1
 Name: glaip-sdk
-Version: 0.6.5b9
+Version: 0.6.6
 Summary: Python SDK for GL AIP (GDP Labs AI Agent Package) - Simplified CLI Design
 License: MIT
 Author: Raymond Christopher
 Author-email: raymond.christopher@gdplabs.id
-Requires-Python: >=3.11,<3.13
+Requires-Python: >=3.11,<3.14
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 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: click (>=8.2.0,<8.3.0)
 Requires-Dist: gllm-core-binary (>=0.1.0)
 Requires-Dist: gllm-tools-binary (>=0.1.3)
 Requires-Dist: httpx (>=0.28.1)
 Requires-Dist: langchain-core (>=0.3.0)
 Requires-Dist: packaging (>=23.2)
-Requires-Dist: pre-commit (>=4.3.0) ; extra == "dev"
 Requires-Dist: pydantic (>=2.0.0)
-Requires-Dist: pytest (>=7.0.0) ; extra == "dev"
-Requires-Dist: pytest-asyncio (>=0.23.6) ; extra == "dev"
-Requires-Dist: pytest-cov (>=4.0.0) ; extra == "dev"
-Requires-Dist: pytest-dotenv (>=0.5.2) ; extra == "dev"
-Requires-Dist: pytest-timeout (>=2.3.1) ; extra == "dev"
-Requires-Dist: pytest-xdist (>=3.8.0) ; extra == "dev"
 Requires-Dist: python-dotenv (>=1.1.1,<2.0.0)
 Requires-Dist: pyyaml (>=6.0.0)
 Requires-Dist: questionary (>=2.1.0,<3.0.0)
 Requires-Dist: readchar (>=4.2.1,<5.0.0)
 Requires-Dist: rich (>=13.0.0)
-Requires-Dist: ruff (>=0.14.0) ; extra == "dev"
 Requires-Dist: textual (>=0.52.0)
 Description-Content-Type: text/markdown