elidia-agent-cli 2.1.0__tar.gz → 2.2.1__tar.gz

{elidia_agent_cli-2.1.0 → elidia_agent_cli-2.2.1}/MANIFEST.in

@@ -1,5 +1,6 @@
 graft skills
 graft optional-skills
+graft optional-mcps
 graft locales
 graft assets
 # Bundled plugin manifests (plugin.yaml / plugin.yml). Without these the

{elidia_agent_cli-2.1.0/elidia_agent_cli.egg-info → elidia_agent_cli-2.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: elidia-agent-cli
-Version: 2.1.0
+Version: 2.2.1
 Summary: Multi-platform AI agent for the terminal and messaging apps — part of the AiUtils.io ecosystem, powered by Elidia Technology
 Author: AiUtils
 License-Expression: MIT
@@ -317,6 +317,7 @@ All documentation lives at **[aiutils.io/elidia](https://aiutils.io/elidia)** an
 | [Contributing](docs/contributing.md)                                       | Development setup, PR process, code style                  |
 | [CLI Reference](docs/cli-commands.md)                                      | All commands and flags                                     |
 | [Environment Variables](docs/environment-variables.md)                     | Complete env var reference                                 |
+| [Troubleshooting — Windows / macOS / Linux](docs/troubleshooting-windows.md) | Shell, MCP, skills, and permissions fixes                 |
 
 ---
 

{elidia_agent_cli-2.1.0 → elidia_agent_cli-2.2.1}/README.md

@@ -151,6 +151,7 @@ All documentation lives at **[aiutils.io/elidia](https://aiutils.io/elidia)** an
 | [Contributing](docs/contributing.md)                                       | Development setup, PR process, code style                  |
 | [CLI Reference](docs/cli-commands.md)                                      | All commands and flags                                     |
 | [Environment Variables](docs/environment-variables.md)                     | Complete env var reference                                 |
+| [Troubleshooting — Windows / macOS / Linux](docs/troubleshooting-windows.md) | Shell, MCP, skills, and permissions fixes                 |
 
 ---
 

{elidia_agent_cli-2.1.0 → elidia_agent_cli-2.2.1/elidia_agent_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: elidia-agent-cli
-Version: 2.1.0
+Version: 2.2.1
 Summary: Multi-platform AI agent for the terminal and messaging apps — part of the AiUtils.io ecosystem, powered by Elidia Technology
 Author: AiUtils
 License-Expression: MIT
@@ -317,6 +317,7 @@ All documentation lives at **[aiutils.io/elidia](https://aiutils.io/elidia)** an
 | [Contributing](docs/contributing.md)                                       | Development setup, PR process, code style                  |
 | [CLI Reference](docs/cli-commands.md)                                      | All commands and flags                                     |
 | [Environment Variables](docs/environment-variables.md)                     | Complete env var reference                                 |
+| [Troubleshooting — Windows / macOS / Linux](docs/troubleshooting-windows.md) | Shell, MCP, skills, and permissions fixes                 |
 
 ---
 

{elidia_agent_cli-2.1.0 → elidia_agent_cli-2.2.1}/elidia_agent_cli.egg-info/SOURCES.txt

@@ -278,21 +278,6 @@ elidia_cli/proxy/adapters/__init__.py
 elidia_cli/proxy/adapters/base.py
 elidia_cli/proxy/adapters/elidia_portal.py
 elidia_cli/proxy/adapters/xai.py
-elidia_cli/web_dist/favicon.ico
-elidia_cli/web_dist/index.html
-elidia_cli/web_dist/assets/Collapse-Bold-mgICk9-_.woff2
-elidia_cli/web_dist/assets/Collapse-Regular-DysayoTY.woff2
-elidia_cli/web_dist/assets/Mondwest-Regular-CWscgue7.woff2
-elidia_cli/web_dist/assets/RulesCompressed-Medium-CA76_CrB.woff2
-elidia_cli/web_dist/assets/RulesCompressed-Regular-BSXFyF4x.woff2
-elidia_cli/web_dist/assets/RulesExpanded-Bold-DZA7s8Pa.woff2
-elidia_cli/web_dist/assets/RulesExpanded-Regular-l8uVympt.woff2
-elidia_cli/web_dist/assets/filler-bg0-DxMaWJpb.webp
-elidia_cli/web_dist/assets/index-CxcJJrTY.css
-elidia_cli/web_dist/assets/index-D8wWbP7c.js
-elidia_cli/web_dist/fonts-terminal/JetBrainsMono-Bold.woff2
-elidia_cli/web_dist/fonts-terminal/JetBrainsMono-Italic.woff2
-elidia_cli/web_dist/fonts-terminal/JetBrainsMono-Regular.woff2
 gateway/__init__.py
 gateway/channel_directory.py
 gateway/config.py
@@ -384,6 +369,12 @@ locales/tr.yaml
 locales/uk.yaml
 locales/zh-hant.yaml
 locales/zh.yaml
+optional-mcps/context7/manifest.yaml
+optional-mcps/linear/manifest.yaml
+optional-mcps/markitdown/manifest.yaml
+optional-mcps/n8n/manifest.yaml
+optional-mcps/sequential-thinking/manifest.yaml
+optional-mcps/time/manifest.yaml
 optional-skills/DESCRIPTION.md
 optional-skills/autonomous-ai-agents/DESCRIPTION.md
 optional-skills/autonomous-ai-agents/antigravity-cli/SKILL.md

{elidia_agent_cli-2.1.0 → elidia_agent_cli-2.2.1}/elidia_cli/__init__.py

@@ -14,7 +14,7 @@ Provides subcommands for:
 import os
 import sys
 
-__version__ = "2.1.0"
+__version__ = "2.2.1"
 __release_date__ = "2026.9.24"
 
 

{elidia_agent_cli-2.1.0 → elidia_agent_cli-2.2.1}/elidia_cli/auth.py

@@ -585,6 +585,18 @@ def _resolve_api_key_provider_secret(
             pass
         return "", ""
 
+    if provider_id == "aiutils":
+        # The AiUtils Developer API key (Elidia Portal) may live only in the OS
+        # keychain: `elidia key store` / `elidia auth add elidia` put it there
+        # and deliberately keep it out of the environment (B13). Resolve it with
+        # the same precedence the tools use (session → keychain → environment)
+        # so chat and tools never bill different keys. Read into this variable,
+        # never exported.
+        from elidia_cli import key_store
+        shared_key = (key_store.load() or "").strip()
+        if has_usable_secret(shared_key):
+            return shared_key, key_store.source()
+
     from elidia_cli.config import get_env_value
     for env_var in pconfig.api_key_env_vars:
         # Check both os.environ and ~/.elidia/.env file

{elidia_agent_cli-2.1.0 → elidia_agent_cli-2.2.1}/elidia_cli/auth_commands.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import logging
 import math
 import sys
 import time
@@ -28,12 +29,34 @@ from agent.credential_pool import (
 )
 import elidia_cli.auth as auth_mod
 from elidia_cli.auth import PROVIDER_REGISTRY
+from elidia_cli import key_cli
 from elidia_constants import OPENROUTER_BASE_URL
 from elidia_cli.secret_prompt import masked_secret_prompt
 
+logger = logging.getLogger(__name__)
+
 
 # Providers that support OAuth login in addition to API keys.
-_OAUTH_CAPABLE_PROVIDERS = {"anthropic", "elidia", "openai-codex", "xai-oauth", "qwen-oauth", "google-gemini-cli", "minimax-oauth"}
+#
+# "elidia" is intentionally NOT here. It used to be a device-code OAuth
+# provider, but the OAuth identity server it pointed at
+# (developer.aiutils.io/api/oauth/device/code) does not exist — the Portal
+# now issues AiUtils Developer API keys instead. `auth_add_command` handles
+# "elidia" as a special case before this set is even consulted.
+_OAUTH_CAPABLE_PROVIDERS = {"anthropic", "openai-codex", "xai-oauth", "qwen-oauth", "google-gemini-cli", "minimax-oauth"}
+
+# Elidia Portal authenticates with an AiUtils Developer API key, not OAuth.
+_ELIDIA_API_KEY_GUIDANCE = (
+    "Elidia Portal authenticates with an AiUtils Developer API key, not "
+    "OAuth. Storing it below via the OS keychain (same as `elidia key "
+    "store`)."
+)
+_ELIDIA_OAUTH_REJECTED_MESSAGE = (
+    "`elidia auth add elidia --type oauth` is no longer supported — Elidia "
+    "Portal authenticates with an AiUtils Developer API key now. Run "
+    "`elidia auth add elidia` (no --type flag) or `elidia key store`, or "
+    "set the AIUTILS_API_KEY / ELIDIA_KEY environment variable."
+)
 
 
 def _get_custom_provider_names() -> list:
@@ -79,6 +102,8 @@ def _normalize_provider(provider: str) -> str:
         return "openrouter"
     if normalized in {"grok-oauth", "xai-oauth", "x-ai-oauth", "xai-grok-oauth"}:
         return "xai-oauth"
+    if normalized == "elidia-portal":
+        return "elidia"
     # Check if it matches a custom provider name
     custom_key = _resolve_custom_provider_input(normalized)
     if custom_key:
@@ -174,6 +199,24 @@ def auth_add_command(args) -> None:
         else:
             requested_type = AUTH_TYPE_OAUTH if provider in _OAUTH_CAPABLE_PROVIDERS else AUTH_TYPE_API_KEY
 
+    if provider == "elidia":
+        logger.debug(
+            "Entered into auth_add_command: provider=elidia requested_type=%s",
+            requested_type,
+        )
+        # Elidia Portal used to be a device-code OAuth provider. That
+        # identity server no longer exists (see AIUT-3434) — the Portal now
+        # issues AiUtils Developer API keys. Route straight to the same
+        # OS-keychain flow `elidia key store` uses instead of a second,
+        # credential-pool-based implementation.
+        if requested_type == AUTH_TYPE_OAUTH:
+            raise SystemExit(_ELIDIA_OAUTH_REJECTED_MESSAGE)
+        print(_ELIDIA_API_KEY_GUIDANCE)
+        rc = key_cli.cmd_key_store(SimpleNamespace(key=getattr(args, "api_key", None)))
+        if rc:
+            raise SystemExit(rc)
+        return
+
     pool = load_pool(provider)
 
     # Clear ALL suppressions for this provider — re-adding a credential is
@@ -246,66 +289,6 @@ def auth_add_command(args) -> None:
         print(f'Added {provider} OAuth credential #{len(pool.entries())}: "{entry.label}"')
         return
 
-    if provider == "elidia":
-        # Codex-style auto-import: if a shared Elidia credential lives at
-        # <elidia-root>/shared/elidia_auth.json (written by any previous
-        # successful login), offer to import it instead of running the
-        # full device-code flow. This makes `elidia --profile <name>
-        # auth add elidia --type oauth` a one-tap operation for users who
-        # run multiple profiles.
-        shared = auth_mod._read_shared_elidia_state()
-        if shared:
-            try:
-                path = auth_mod._elidia_shared_store_path()
-            except RuntimeError:
-                path = None
-            print()
-            if path:
-                print(f"Found existing Elidia OAuth credentials at {path}")
-            else:
-                print("Found existing shared Elidia OAuth credentials")
-            try:
-                do_import = input("Import these credentials? [Y/n]: ").strip().lower()
-            except (EOFError, KeyboardInterrupt):
-                do_import = "y"
-            if do_import in {"", "y", "yes"}:
-                print("Rehydrating Elidia session from shared credentials...")
-                rehydrated = auth_mod._try_import_shared_elidia_state(
-                    timeout_seconds=getattr(args, "timeout", None) or 15.0,
-                )
-                if rehydrated is not None:
-                    custom_label = (getattr(args, "label", None) or "").strip() or None
-                    entry = auth_mod.persist_elidia_credentials(rehydrated, label=custom_label)
-                    shown_label = entry.label if entry is not None else label_from_token(
-                        rehydrated.get("access_token", ""), _oauth_default_label(provider, 1),
-                    )
-                    print(f'Imported {provider} OAuth credentials: "{shown_label}"')
-                    return
-                # Rehydrate failed (expired refresh_token, portal down, etc.)
-                # — fall through to device-code flow.
-                print("Could not refresh shared credentials — falling back to device-code login.")
-
-        creds = auth_mod._elidia_device_code_login(
-            portal_base_url=getattr(args, "portal_url", None),
-            inference_base_url=getattr(args, "inference_url", None),
-            client_id=getattr(args, "client_id", None),
-            scope=getattr(args, "scope", None),
-            open_browser=not getattr(args, "no_browser", False),
-            timeout_seconds=getattr(args, "timeout", None) or 15.0,
-            insecure=bool(getattr(args, "insecure", False)),
-            ca_bundle=getattr(args, "ca_bundle", None),
-        )
-        # Honor `--label <name>` so elidia matches other providers' UX.  The
-        # helper embeds this into providers.elidia so that label_from_token
-        # doesn't overwrite it on every subsequent load_pool("elidia").
-        custom_label = (getattr(args, "label", None) or "").strip() or None
-        entry = auth_mod.persist_elidia_credentials(creds, label=custom_label)
-        shown_label = entry.label if entry is not None else label_from_token(
-            creds.get("access_token", ""), _oauth_default_label(provider, 1),
-        )
-        print(f'Saved {provider} OAuth device-code credentials: "{shown_label}"')
-        return
-
     if provider == "openai-codex":
         creds = auth_mod._codex_device_code_login()
         label = (getattr(args, "label", None) or "").strip() or label_from_token(

{elidia_agent_cli-2.1.0 → elidia_agent_cli-2.2.1}/elidia_cli/main.py

@@ -3320,222 +3320,33 @@ def _model_flow_openrouter(config, current_model=""):
 
 
 def _model_flow_elidia(config, current_model="", args=None):
-    """Elidia Portal provider: ensure logged in, then pick model."""
-    from elidia_cli.auth import (
-        get_provider_auth_state,
-        _prompt_model_selection,
-        _save_model_choice,
-        _update_config_for_provider,
-        resolve_elidia_runtime_credentials,
-        AuthError,
-        format_auth_error,
-        _login_elidia,
-        PROVIDER_REGISTRY,
-    )
-    from elidia_cli.config import (
-        get_env_value,
-        load_config,
-        save_config,
-        save_env_value,
-    )
-    from elidia_cli.elidia_subscription import prompt_enable_tool_gateway
-
-    state = get_provider_auth_state("elidia")
-    if not state or not state.get("access_token"):
-        print("Not logged into Elidia Portal. Starting login...")
-        print()
-        try:
-            mock_args = argparse.Namespace(
-                portal_url=getattr(args, "portal_url", None),
-                inference_url=getattr(args, "inference_url", None),
-                client_id=getattr(args, "client_id", None),
-                scope=getattr(args, "scope", None),
-                no_browser=bool(getattr(args, "no_browser", False)),
-                timeout=getattr(args, "timeout", None) or 15.0,
-                ca_bundle=getattr(args, "ca_bundle", None),
-                insecure=bool(getattr(args, "insecure", False)),
-            )
-            _login_elidia(mock_args, PROVIDER_REGISTRY["elidia"])
-            # Offer Tool Gateway enablement for paid subscribers
-            try:
-                _refreshed = load_config() or {}
-                prompt_enable_tool_gateway(_refreshed)
-            except Exception:
-                pass
-        except SystemExit:
-            print("Login cancelled or failed.")
-            return
-        except Exception as exc:
-            print(f"Login failed: {exc}")
-            return
-        # login_elidia already handles model selection + config update
-        return
-
-    # Already logged in — use curated model list (same as OpenRouter defaults).
-    # The live /models endpoint returns hundreds of models; the curated list
-    # shows only agentic models users recognize from OpenRouter.
-    from elidia_cli.models import (
-        get_curated_elidia_model_ids,
-        get_pricing_for_provider,
-        check_elidia_free_tier,
-        partition_elidia_models_by_tier,
-        union_with_portal_free_recommendations,
-        union_with_portal_paid_recommendations,
-    )
-
-    model_ids = get_curated_elidia_model_ids()
-    if not model_ids:
-        print("No curated models available for Elidia Portal.")
-        return
-
-    # Verify credentials are still valid (catches expired sessions early)
-    try:
-        creds = resolve_elidia_runtime_credentials()
-    except Exception as exc:
-        relogin = isinstance(exc, AuthError) and exc.relogin_required
-        msg = format_auth_error(exc) if isinstance(exc, AuthError) else str(exc)
-        if relogin:
-            print(f"Session expired: {msg}")
-            print("Re-authenticating with Elidia Portal...\n")
-            try:
-                mock_args = argparse.Namespace(
-                    portal_url=None,
-                    inference_url=None,
-                    client_id=None,
-                    scope=None,
-                    no_browser=False,
-                    timeout=15.0,
-                    ca_bundle=None,
-                    insecure=False,
-                )
-                _login_elidia(mock_args, PROVIDER_REGISTRY["elidia"])
-            except Exception as login_exc:
-                print(f"Re-login failed: {login_exc}")
-            return
-        print(f"Could not verify credentials: {msg}")
-        return
-
-    # Fetch live pricing (non-blocking — returns empty dict on failure)
-    pricing = get_pricing_for_provider("elidia")
-
-    # Force fresh account data for model selection so recent credit purchases
-    # are reflected immediately.
-    free_tier = check_elidia_free_tier(force_fresh=True)
-    if not free_tier:
-        try:
-            refreshed_creds = resolve_elidia_runtime_credentials(
-                force_refresh=True,
-            )
-            if refreshed_creds:
-                creds = refreshed_creds
-        except Exception:
-            # Runtime inference has its own paid-entitlement recovery path; do
-            # not block model selection if this opportunistic refresh fails.
-            pass
+    """Elidia Portal: authenticate with an AiUtils Developer API key, then pick a model.
 
-    # Resolve portal URL early — needed both for upgrade links and for the
-    # freeRecommendedModels endpoint below.
-    _elidia_portal_url = ""
-    try:
-        _elidia_state = get_provider_auth_state("elidia")
-        if _elidia_state:
-            _elidia_portal_url = _elidia_state.get("portal_base_url", "")
-    except Exception:
-        pass
-
-    # For free users: partition models into selectable/unavailable based on
-    # whether they are free per the Portal-reported pricing.  First augment
-    # with the Portal's freeRecommendedModels list so newly-launched free
-    # models show up even if this CLI build's hardcoded curated list and
-    # docs-hosted manifest haven't caught up yet.
-    #
-    # For paid users: mirror the same idea with paidRecommendedModels so
-    # newly-launched paid models surface in the picker too — independent
-    # of CLI release cadence.
-    unavailable_models: list[str] = []
-    unavailable_message = ""
-    if free_tier:
-        try:
-            from elidia_cli.elidia_account import (
-                format_elidia_portal_entitlement_message,
-                get_elidia_portal_account_info,
-            )
-
-            _account_info = get_elidia_portal_account_info(force_fresh=True)
-            unavailable_message = (
-                format_elidia_portal_entitlement_message(
-                    _account_info,
-                    capability="paid Elidia models",
-                )
-                or ""
-            )
-        except Exception:
-            unavailable_message = ""
-        model_ids, pricing = union_with_portal_free_recommendations(
-            model_ids, pricing, _elidia_portal_url,
-        )
-        model_ids, unavailable_models = partition_elidia_models_by_tier(
-            model_ids, pricing, free_tier=True
-        )
-    else:
-        model_ids, pricing = union_with_portal_paid_recommendations(
-            model_ids, pricing, _elidia_portal_url,
-        )
-
-    if not model_ids and not unavailable_models:
-        print("No models available for Elidia Portal after filtering.")
-        return
-
-    if free_tier and not model_ids:
-        print("No free models currently available.")
-        if unavailable_models:
-            from elidia_cli.auth import DEFAULT_ELIDIA_PORTAL_URL
-
-            _url = (_elidia_portal_url or DEFAULT_ELIDIA_PORTAL_URL).rstrip("/")
-            print(unavailable_message or f"Upgrade at {_url} to access paid models.")
-        return
+    The Portal issues ``ak-dev-*`` Developer API keys (https://developer.aiutils.io)
+    served by the ``aiutils`` provider. Its former OAuth device-code endpoint does
+    not exist (HTTP 405), so this flow never starts an OAuth login. ``args`` is
+    accepted for the callers that still pass their parsed CLI flags.
+    """
+    logger.debug(f"Entered into _model_flow_elidia: current_model={current_model!r}")
+    from elidia_cli import key_cli, key_store
+    from elidia_cli.auth import PROVIDER_REGISTRY, _resolve_api_key_provider_secret
 
-    print(
-        f'Showing {len(model_ids)} curated models — use "Enter custom model name" for others.'
+    existing_key, _source = _resolve_api_key_provider_secret(
+        "aiutils", PROVIDER_REGISTRY["aiutils"]
     )
+    if not existing_key:
+        print("Elidia Portal uses an AiUtils Developer API key (ak-dev-…).")
+        print("Create one at https://developer.aiutils.io/api-keys")
+        print()
+        if key_store.backend_available():
+            # Validates the ak-dev- format and keeps the key in the OS keychain,
+            # out of the environment every agent subprocess inherits (B13).
+            if key_cli.cmd_key_store(argparse.Namespace(key=None)) != 0:
+                return
+        # Without a keychain, the generic flow below prompts for the key and
+        # saves it to ~/.elidia/.env.
 
-    selected = _prompt_model_selection(
-        model_ids,
-        current_model=current_model,
-        pricing=pricing,
-        unavailable_models=unavailable_models,
-        portal_url=_elidia_portal_url,
-        unavailable_message=unavailable_message,
-    )
-    if selected:
-        _save_model_choice(selected)
-        # Reactivate Elidia as the provider and update config
-        inference_url = creds.get("base_url", "")
-        _update_config_for_provider("elidia", inference_url)
-        current_model_cfg = config.get("model")
-        if isinstance(current_model_cfg, dict):
-            model_cfg = dict(current_model_cfg)
-        elif isinstance(current_model_cfg, str) and current_model_cfg.strip():
-            model_cfg = {"default": current_model_cfg.strip()}
-        else:
-            model_cfg = {}
-        model_cfg["provider"] = "elidia"
-        model_cfg["default"] = selected
-        if inference_url and inference_url.strip():
-            model_cfg["base_url"] = inference_url.rstrip("/")
-        else:
-            model_cfg.pop("base_url", None)
-        config["model"] = model_cfg
-        # Clear any custom endpoint that might conflict
-        if get_env_value("OPENAI_BASE_URL"):
-            save_env_value("OPENAI_BASE_URL", "")
-            save_env_value("OPENAI_API_KEY", "")
-        save_config(config)
-        print(f"Default model set to: {selected} (via Elidia Portal)")
-        # Offer Tool Gateway enablement for paid subscribers
-        prompt_enable_tool_gateway(config)
-    else:
-        print("No change.")
+    _model_flow_api_key_provider(config, "aiutils", current_model)
 
 
 def _model_flow_openai_codex(config, current_model=""):
@@ -5336,6 +5147,25 @@ def _prompt_api_key(pconfig, existing_key: str, provider_id: str = "") -> tuple:
             return LMSTUDIO_NOAUTH_PLACEHOLDER
         return entered
 
+    def _save_key(new_key: str) -> bool:
+        """Persist *new_key*. The AiUtils Developer API key is validated and kept
+        in the OS keychain when one exists (B13), so chat and tools share it."""
+        if provider_id != "aiutils":
+            save_env_value(key_env, new_key)
+            return True
+        from elidia_cli import key_store
+        ok, problem = key_store.validate(new_key)
+        if not ok:
+            print(f"  Not saved: {problem}")
+            return False
+        if key_store.backend_available():
+            stored, problem = key_store.store(new_key)
+            if stored:
+                return True
+            print(f"  {problem} Saving to ~/.elidia/.env instead.")
+        save_env_value(key_env, new_key)
+        return True
+
     # First-time entry ────────────────────────────────────────────────────
     if not existing_key:
         print(f"No {pconfig.name} API key configured.")
@@ -5345,7 +5175,8 @@ def _prompt_api_key(pconfig, existing_key: str, provider_id: str = "") -> tuple:
         if not new_key:
             print("Cancelled.")
             return "", True
-        save_env_value(key_env, new_key)
+        if not _save_key(new_key):
+            return "", True
         print("API key saved.")
         print()
         return new_key, False
@@ -5371,13 +5202,19 @@ def _prompt_api_key(pconfig, existing_key: str, provider_id: str = "") -> tuple:
             print("  No change.")
             print()
             return existing_key, False
-        save_env_value(key_env, new_key)
+        if not _save_key(new_key):
+            print("  No change.")
+            print()
+            return existing_key, False
         print("  API key updated.")
         print()
         return new_key, False
 
     if choice.startswith("c"):
         save_env_value(key_env, "")
+        if provider_id == "aiutils":
+            from elidia_cli import key_store
+            key_store.delete()
         print(
             f"  API key cleared.  Re-run `elidia setup` to configure {pconfig.name} again."
         )
@@ -5917,6 +5754,10 @@ def _model_flow_api_key_provider(config, provider_id, current_model=""):
         existing_key = get_env_value(ev) or os.getenv(ev, "")
         if existing_key:
             break
+    if not existing_key and provider_id == "aiutils":
+        # The AiUtils Developer API key may live only in the OS keychain.
+        from elidia_cli.auth import _resolve_api_key_provider_secret
+        existing_key, _ = _resolve_api_key_provider_secret(provider_id, pconfig)
 
     existing_key, abort = _prompt_api_key(
         pconfig, existing_key, provider_id=provider_id

{elidia_agent_cli-2.1.0 → elidia_agent_cli-2.2.1}/elidia_cli/mcp_config.py

@@ -177,6 +177,7 @@ def _probe_single_server(
         _run_on_mcp_loop,
         _connect_server,
         _stop_mcp_loop,
+        _format_connect_error,
     )
 
     _ensure_mcp_loop()
@@ -198,7 +199,13 @@ def _probe_single_server(
     try:
         _run_on_mcp_loop(_probe(), timeout=connect_timeout + 10)
     except BaseException as exc:
-        raise _unwrap_exception_group(exc) from None
+        # Surface the root cause through the same formatter the runtime uses,
+        # so `elidia mcp test` / the web "test connection" endpoint report
+        # "missing executable 'uvx' (install uv …)" instead of the opaque
+        # "[WinError 2] The system cannot find the file specified" or
+        # "unhandled errors in a TaskGroup". _format_connect_error unwraps
+        # anyio ExceptionGroups itself (see #3416).
+        raise RuntimeError(_format_connect_error(exc)) from None
     finally:
         _stop_mcp_loop()
 
@@ -221,22 +228,6 @@ def _oauth_tokens_present(name: str) -> bool:
         return True
 
 
-def _unwrap_exception_group(exc: BaseException) -> Exception:
-    """Extract the root-cause exception from anyio TaskGroup wrappers.
-
-    The MCP SDK uses anyio task groups, which wrap errors in
-    ``BaseExceptionGroup`` / ``ExceptionGroup``.  This makes error
-    messages opaque ("unhandled errors in a TaskGroup").  We unwrap
-    to surface the real cause (e.g. "401 Unauthorized").
-    """
-    while isinstance(exc, BaseExceptionGroup) and exc.exceptions:
-        exc = exc.exceptions[0]
-    # Return a plain Exception so callers can catch normally
-    if isinstance(exc, Exception):
-        return exc
-    return RuntimeError(str(exc))
-
-
 # ─── elidia mcp add ──────────────────────────────────────────────────────────
 
 def cmd_mcp_add(args):