nexo-brain 7.25.6 → 7.26.0

package/src/cli.py

@@ -2470,6 +2470,7 @@ def _clients_sync(args):
         enabled_clients=("claude_code", "claude_desktop", "codex"),
         preferences=load_client_preferences(),
         auto_install_missing_claude=bool(getattr(args, "auto_install_missing_claude", False)),
+        auto_install_missing_codex=bool(getattr(args, "auto_install_missing_codex", False)),
     )
     if args.json:
         print(json.dumps(result, indent=2, ensure_ascii=False))
@@ -2515,6 +2516,8 @@ def _preferences(args):
     from client_preferences import (
         BACKEND_NONE,
         AUTOMATION_BACKEND_KEYS,
+        PROVIDER_KEYS,
+        PROVIDER_NONE,
         load_client_preferences,
         normalize_default_terminal_client,
         save_client_preferences,
@@ -2536,7 +2539,21 @@ def _preferences(args):
         automation_enabled = False
 
     automation_backend = getattr(args, "automation_backend", None)
-    automation_changed = automation_enabled is not None or automation_backend is not None
+    chat_provider = getattr(args, "chat_provider", None)
+    automation_provider = getattr(args, "automation_provider", None)
+    automation_changed = (
+        automation_enabled is not None
+        or automation_backend is not None
+        or automation_provider is not None
+    )
+    provider_changed = chat_provider is not None or automation_provider is not None
+
+    if automation_backend and automation_provider:
+        print(
+            "[NEXO] Use either --automation-provider or --automation-backend, not both.",
+            file=sys.stderr,
+        )
+        return 2
 
     if args.resonance:
         tier = args.resonance.lower()
@@ -2560,11 +2577,13 @@ def _preferences(args):
                 interactive_clients=prefs.get("interactive_clients"),
             ) or "claude_code"
 
-    if tier or automation_changed:
+    if tier or automation_changed or provider_changed:
         save_client_preferences(
             default_resonance=tier,
             automation_enabled=automation_enabled,
             automation_backend=automation_backend,
+            selected_chat_provider=chat_provider,
+            automation_provider=automation_provider,
             automation_user_override=True if automation_changed else None,
         )
         if tier:
@@ -2579,8 +2598,9 @@ def _preferences(args):
     ).strip().lower()
     current_resonance = calibration_value or schedule_value or DEFAULT_RESONANCE
 
-    if args.show or tier or automation_changed:
+    if args.show or tier or automation_changed or provider_changed:
         is_explicit = bool(calibration_value or schedule_value)
+        provider_runtime = prefs.get("provider_runtime") if isinstance(prefs.get("provider_runtime"), dict) else {}
         payload = {
             "default_resonance": current_resonance,
             "default_resonance_is_explicit": is_explicit,
@@ -2594,6 +2614,10 @@ def _preferences(args):
             "automation_user_override": bool(prefs.get("automation_user_override", False)),
             "available_automation_backends": list(AUTOMATION_BACKEND_KEYS),
             "default_terminal_client": str(prefs.get("default_terminal_client") or "claude_code"),
+            "selected_chat_provider": str(provider_runtime.get("selected_chat_provider") or "anthropic"),
+            "automation_provider": str(provider_runtime.get("automation_provider") or PROVIDER_NONE),
+            "available_providers": list(PROVIDER_KEYS),
+            "provider_runtime": provider_runtime,
         }
         if args.json:
             print(json.dumps(payload, indent=2, ensure_ascii=False))
@@ -2605,6 +2629,10 @@ def _preferences(args):
                 + ("enabled" if payload["automation_enabled"] else "disabled")
                 + f" · backend={payload['automation_backend']}"
             )
+            print(
+                "provider = "
+                + f"chat:{payload['selected_chat_provider']} · automation:{payload['automation_provider']}"
+            )
             if not is_explicit:
                 print(f"  (inherited from DEFAULT_RESONANCE; run "
                       f"`nexo preferences --resonance alto` to set explicitly)")
@@ -2614,13 +2642,69 @@ def _preferences(args):
     print(
         "Usage: nexo preferences [--resonance TIER] "
         "[--automation-enabled|--automation-disabled] "
-        "[--automation-backend BACKEND] [--show] [--json]"
+        "[--automation-backend BACKEND|--automation-provider PROVIDER] "
+        "[--chat-provider PROVIDER] [--show] [--json]"
     )
     print(f"  resonance tiers: {', '.join(TIERS)}")
     print(f"  current default: {current_resonance}")
     return 0
 
 
+def _provider(args):
+    """Provider runtime status/selection for Desktop and terminal parity."""
+    from client_preferences import (
+        PROVIDER_KEYS,
+        detect_installed_clients,
+        load_client_preferences,
+        provider_to_client,
+        save_client_preferences,
+    )
+
+    command = getattr(args, "provider_command", "status") or "status"
+    prefs = load_client_preferences()
+    provider_runtime = prefs.get("provider_runtime") if isinstance(prefs.get("provider_runtime"), dict) else {}
+    if command == "select":
+        target = str(args.provider or "").strip().lower()
+        if target not in PROVIDER_KEYS:
+            print(f"[NEXO] Unknown provider '{target}'. Valid values: {', '.join(PROVIDER_KEYS)}.", file=sys.stderr)
+            return 2
+        chat_provider = None if getattr(args, "automation_only", False) else target
+        automation_provider = None if getattr(args, "chat_only", False) else target
+        save_client_preferences(
+            selected_chat_provider=chat_provider,
+            automation_provider=automation_provider,
+            automation_user_override=True if automation_provider is not None else None,
+        )
+        prefs = load_client_preferences()
+        provider_runtime = prefs.get("provider_runtime") if isinstance(prefs.get("provider_runtime"), dict) else {}
+
+    detected = detect_installed_clients()
+    payload = {
+        "selected_chat_provider": str(provider_runtime.get("selected_chat_provider") or "anthropic"),
+        "automation_provider": str(provider_runtime.get("automation_provider") or "none"),
+        "automation_backend": str(prefs.get("automation_backend") or "none"),
+        "default_terminal_client": str(prefs.get("default_terminal_client") or "claude_code"),
+        "providers": provider_runtime.get("providers") or {},
+        "installed_clients": detected,
+    }
+    for provider in PROVIDER_KEYS:
+        client = provider_to_client(provider)
+        payload["providers"].setdefault(provider, {})
+        payload["providers"][provider]["client"] = client
+        payload["providers"][provider]["detected"] = detected.get(client, {})
+
+    if getattr(args, "json", False):
+        print(json.dumps(payload, indent=2, ensure_ascii=False))
+    else:
+        print(f"chat_provider = {payload['selected_chat_provider']}")
+        print(f"automation_provider = {payload['automation_provider']} · backend={payload['automation_backend']}")
+        for provider in PROVIDER_KEYS:
+            detected_provider = payload["providers"].get(provider, {}).get("detected", {})
+            state = "installed" if detected_provider.get("installed") else "missing"
+            print(f"  {provider}: {state}")
+    return 0
+
+
 def _contributor_status(args):
     public_contribution = _load_public_contribution_support()
     config = public_contribution["refresh_public_contribution_state"](
@@ -4058,6 +4142,11 @@ def main():
         action="store_true",
         help="Install Claude Code automatically when the selected runtime needs it and it is missing.",
     )
+    clients_sync_p.add_argument(
+        "--auto-install-missing-codex",
+        action="store_true",
+        help="Install Codex automatically when the selected runtime needs it and it is missing.",
+    )
 
     # -- preferences --
     preferences_parser = sub.add_parser(
@@ -4093,8 +4182,30 @@ def main():
         choices=["claude_code", "codex", "none"],
         help="Backend used by background automations when they are enabled.",
     )
+    preferences_parser.add_argument(
+        "--chat-provider",
+        choices=["anthropic", "openai"],
+        help="Provider used for new chat sessions: Anthropic runs Claude Code, OpenAI runs Codex.",
+    )
+    preferences_parser.add_argument(
+        "--automation-provider",
+        choices=["anthropic", "openai", "none"],
+        help="Provider used by background automations. 'none' pauses the runtime instead of falling back.",
+    )
     preferences_parser.add_argument("--json", action="store_true", help="JSON output")
 
+    # -- provider --
+    provider_parser = sub.add_parser("provider", help="Provider runtime status and selection")
+    provider_sub = provider_parser.add_subparsers(dest="provider_command")
+    provider_status_p = provider_sub.add_parser("status", help="Show selected Anthropic/OpenAI runtime")
+    provider_status_p.add_argument("--json", action="store_true", help="JSON output")
+    provider_select_p = provider_sub.add_parser("select", help="Select Anthropic or OpenAI runtime")
+    provider_select_p.add_argument("provider", choices=["anthropic", "openai"], help="Provider to select")
+    provider_scope = provider_select_p.add_mutually_exclusive_group()
+    provider_scope.add_argument("--chat-only", action="store_true", help="Only switch new chat sessions")
+    provider_scope.add_argument("--automation-only", action="store_true", help="Only switch background automation")
+    provider_select_p.add_argument("--json", action="store_true", help="JSON output")
+
     # -- doctor --
     doctor_parser = sub.add_parser("doctor", help="Unified diagnostics")
     doctor_parser.add_argument("--tier", default="boot", choices=["boot", "runtime", "deep", "all"],
@@ -4585,6 +4696,8 @@ def main():
         return 0
     elif args.command == "preferences":
         return _preferences(args)
+    elif args.command == "provider":
+        return _provider(args)
     elif args.command == "doctor":
         return _doctor(args)
     elif args.command == "support-snapshot":

package/src/client_preferences.py

@@ -20,6 +20,22 @@ CLIENT_CLAUDE_CODE = "claude_code"
 CLIENT_CODEX = "codex"
 CLIENT_CLAUDE_DESKTOP = "claude_desktop"
 BACKEND_NONE = "none"
+PROVIDER_ANTHROPIC = "anthropic"
+PROVIDER_OPENAI = "openai"
+PROVIDER_NONE = "none"
+
+PROVIDER_TO_CLIENT = {
+    PROVIDER_ANTHROPIC: CLIENT_CLAUDE_CODE,
+    PROVIDER_OPENAI: CLIENT_CODEX,
+}
+CLIENT_TO_PROVIDER = {
+    CLIENT_CLAUDE_CODE: PROVIDER_ANTHROPIC,
+    CLIENT_CODEX: PROVIDER_OPENAI,
+}
+PROVIDER_KEYS = (
+    PROVIDER_ANTHROPIC,
+    PROVIDER_OPENAI,
+)
 
 INTERACTIVE_CLIENT_KEYS = (
     CLIENT_CLAUDE_CODE,
@@ -67,6 +83,14 @@ AUTOMATION_TASK_PROFILE_TIERS = {
 }
 
 
+def provider_to_client(provider: str | None) -> str:
+    return PROVIDER_TO_CLIENT.get(normalize_provider_key(provider), "")
+
+
+def client_to_provider(client: str | None) -> str:
+    return CLIENT_TO_PROVIDER.get(normalize_client_key(client), "")
+
+
 def _user_home() -> Path:
     return Path(os.environ.get("HOME", str(Path.home()))).expanduser()
 
@@ -158,6 +182,38 @@ def _managed_claude_binary(home: Path | None = None) -> str:
     return ""
 
 
+def _managed_codex_binary(home: Path | None = None) -> str:
+    base = (home or _user_home()).expanduser()
+    managed_prefix = _managed_claude_prefix(base)
+    candidates = [managed_prefix / "bin" / "codex"]
+    for candidate in candidates:
+        try:
+            if candidate.exists() and _path_within(candidate, managed_prefix):
+                return str(candidate)
+        except Exception:
+            continue
+    return ""
+
+
+def _managed_codex_vendor_present(home: Path | None = None) -> bool:
+    base = (home or _user_home()).expanduser()
+    managed_prefix = _managed_claude_prefix(base)
+    package_roots = (
+        managed_prefix / "lib" / "node_modules" / "@openai" / "codex",
+        managed_prefix / "node_modules" / "@openai" / "codex",
+    )
+    for package_root in package_roots:
+        vendor_root = package_root / "vendor"
+        if not vendor_root.exists():
+            continue
+        try:
+            if any(candidate.is_file() for candidate in vendor_root.rglob("bin/codex*")):
+                return True
+        except Exception:
+            continue
+    return False
+
+
 def _coerce_bool(value, default: bool) -> bool:
     if isinstance(value, bool):
         return value
@@ -182,6 +238,7 @@ def default_client_preferences() -> dict:
         "last_terminal_client": "",
         "automation_enabled": True,
         "automation_backend": CLIENT_CLAUDE_CODE,
+        "provider_runtime": default_provider_runtime(),
         # True iff the user has EXPLICITLY changed automation_backend from its
         # installer-chosen value. Installer/update flows (Fase E) only rewrite
         # automation_backend if this flag is False — respects user opt-out.
@@ -204,6 +261,59 @@ def default_client_preferences() -> dict:
     }
 
 
+def default_provider_runtime() -> dict:
+    return {
+        "schema_version": 1,
+        "selected_chat_provider": PROVIDER_ANTHROPIC,
+        "automation_provider": PROVIDER_ANTHROPIC,
+        "automation_backend": CLIENT_CLAUDE_CODE,
+        "providers": {
+            PROVIDER_ANTHROPIC: {
+                "client": CLIENT_CLAUDE_CODE,
+                "runtime_account_status": {
+                    "surface": "desktop_login",
+                    "status": "unknown",
+                    "plan": None,
+                    "last_checked_at": None,
+                    "detail": None,
+                },
+                "install_status": {
+                    "installed": False,
+                    "managed": True,
+                    "binary_path": None,
+                    "version": None,
+                },
+            },
+            PROVIDER_OPENAI: {
+                "client": CLIENT_CODEX,
+                "runtime_account_status": {
+                    "surface": "desktop_login",
+                    "status": "unknown",
+                    "plan": None,
+                    "last_checked_at": None,
+                    "detail": None,
+                },
+                "install_status": {
+                    "installed": False,
+                    "managed": True,
+                    "binary_path": None,
+                    "version": None,
+                },
+            },
+        },
+        "fallback_policy": {
+            "chat": "ask",
+            "automation": "fail_closed",
+        },
+        "last_provider_change": {
+            "changed_at": None,
+            "from_provider": None,
+            "to_provider": None,
+            "source": None,
+        },
+    }
+
+
 def normalize_client_key(value: str | None) -> str:
     candidate = str(value or "").strip().lower().replace("-", "_").replace(" ", "_")
     aliases = {
@@ -221,6 +331,27 @@ def normalize_client_key(value: str | None) -> str:
     return aliases.get(candidate, "")
 
 
+def normalize_provider_key(value: str | None) -> str:
+    candidate = str(value or "").strip().lower().replace("-", "_").replace(" ", "_")
+    aliases = {
+        "": "",
+        "none": PROVIDER_NONE,
+        "off": PROVIDER_NONE,
+        "disabled": PROVIDER_NONE,
+        "false": PROVIDER_NONE,
+        "0": PROVIDER_NONE,
+        "anthropic": PROVIDER_ANTHROPIC,
+        "anthropic_claude": PROVIDER_ANTHROPIC,
+        "anthropic_claude_code": PROVIDER_ANTHROPIC,
+        "claude": PROVIDER_ANTHROPIC,
+        "claude_code": PROVIDER_ANTHROPIC,
+        "openai": PROVIDER_OPENAI,
+        "openai_codex": PROVIDER_OPENAI,
+        "codex": PROVIDER_OPENAI,
+    }
+    return aliases.get(candidate, "")
+
+
 def normalize_backend_key(value: str | None) -> str:
     candidate = str(value or "").strip().lower().replace("-", "_").replace(" ", "_")
     if candidate in {"", "none", "off", "disabled", "false", "0"}:
@@ -231,6 +362,75 @@ def normalize_backend_key(value: str | None) -> str:
     return ""
 
 
+def _provider_from_runtime_payload(value, key: str, fallback_client: str) -> str:
+    if isinstance(value, dict):
+        provider = normalize_provider_key(value.get(key))
+        if provider in PROVIDER_KEYS:
+            return provider
+    return client_to_provider(fallback_client) or PROVIDER_ANTHROPIC
+
+
+def normalize_provider_runtime(
+    value,
+    *,
+    default_terminal_client: str = CLIENT_CLAUDE_CODE,
+    automation_backend: str = CLIENT_CLAUDE_CODE,
+    automation_enabled: bool = True,
+) -> dict:
+    defaults = default_provider_runtime()
+    raw = value if isinstance(value, dict) else {}
+    selected_provider = _provider_from_runtime_payload(
+        raw,
+        "selected_chat_provider",
+        default_terminal_client,
+    )
+    raw_automation_provider = normalize_provider_key(raw.get("automation_provider")) if isinstance(raw, dict) else ""
+    automation_provider = (
+        PROVIDER_NONE
+        if raw_automation_provider == PROVIDER_NONE
+        else _provider_from_runtime_payload(
+            raw,
+            "automation_provider",
+            automation_backend if automation_enabled else BACKEND_NONE,
+        )
+    )
+    if not automation_enabled or automation_backend == BACKEND_NONE:
+        automation_provider = PROVIDER_NONE
+    elif automation_provider not in PROVIDER_KEYS:
+        automation_provider = client_to_provider(automation_backend) or PROVIDER_ANTHROPIC
+
+    providers = defaults["providers"]
+    raw_providers = raw.get("providers") if isinstance(raw.get("providers"), dict) else {}
+    normalized_providers = {}
+    for provider, expected_client in PROVIDER_TO_CLIENT.items():
+        raw_provider = raw_providers.get(provider) if isinstance(raw_providers.get(provider), dict) else {}
+        merged = dict(providers[provider])
+        merged.update({k: v for k, v in raw_provider.items() if k not in {"client"}})
+        merged["client"] = expected_client
+        normalized_providers[provider] = merged
+
+    fallback_policy = raw.get("fallback_policy") if isinstance(raw.get("fallback_policy"), dict) else {}
+    last_provider_change = raw.get("last_provider_change") if isinstance(raw.get("last_provider_change"), dict) else {}
+
+    return {
+        "schema_version": 1,
+        "selected_chat_provider": selected_provider,
+        "automation_provider": automation_provider,
+        "automation_backend": provider_to_client(automation_provider) if automation_provider in PROVIDER_KEYS else BACKEND_NONE,
+        "providers": normalized_providers,
+        "fallback_policy": {
+            "chat": str(fallback_policy.get("chat") or defaults["fallback_policy"]["chat"]),
+            "automation": "fail_closed",
+        },
+        "last_provider_change": {
+            "changed_at": last_provider_change.get("changed_at"),
+            "from_provider": normalize_provider_key(last_provider_change.get("from_provider")) or None,
+            "to_provider": normalize_provider_key(last_provider_change.get("to_provider")) or None,
+            "source": last_provider_change.get("source"),
+        },
+    }
+
+
 def normalize_interactive_clients(value) -> dict[str, bool]:
     if not isinstance(value, dict):
         return dict(default_client_preferences()["interactive_clients"])
@@ -339,7 +539,10 @@ def normalize_automation_user_override(value) -> bool:
 def normalize_automation_backend(value, *, automation_enabled: bool = True) -> str:
     if not automation_enabled:
         return BACKEND_NONE
+    raw = str(value or "").strip().lower()
     candidate = normalize_backend_key(value)
+    if candidate == BACKEND_NONE and raw in {"none", "off", "disabled", "false", "0"}:
+        return BACKEND_NONE
     if candidate in TERMINAL_CLIENT_KEYS:
         return candidate
     return CLIENT_CLAUDE_CODE
@@ -486,12 +689,27 @@ def normalize_client_preferences(
     runtime_profiles = normalize_client_runtime_profiles(
         schedule.get("client_runtime_profiles")
     )
+    provider_runtime = normalize_provider_runtime(
+        schedule.get("provider_runtime"),
+        default_terminal_client=default_terminal_client,
+        automation_backend=automation_backend,
+        automation_enabled=automation_enabled,
+    )
+    selected_client = provider_to_client(provider_runtime.get("selected_chat_provider"))
+    if selected_client in TERMINAL_CLIENT_KEYS:
+        interactive_clients[selected_client] = True
+        default_terminal_client = normalize_default_terminal_client(
+            selected_client,
+            interactive_clients=interactive_clients,
+        )
+    automation_backend = provider_runtime["automation_backend"]
     return {
         "interactive_clients": interactive_clients,
         "default_terminal_client": default_terminal_client,
         "last_terminal_client": last_terminal_client,
         "automation_enabled": automation_enabled,
         "automation_backend": automation_backend,
+        "provider_runtime": provider_runtime,
         "automation_user_override": automation_user_override,
         "client_runtime_profiles": runtime_profiles,
         "automation_task_profiles": normalize_automation_task_profiles(
@@ -530,6 +748,9 @@ def apply_client_preferences(
     last_terminal_client: str | None = None,
     automation_enabled=None,
     automation_backend: str | None = None,
+    provider_runtime: dict | None = None,
+    selected_chat_provider: str | None = None,
+    automation_provider: str | None = None,
     automation_user_override: bool | None = None,
     client_runtime_profiles: dict | None = None,
     automation_task_profiles: dict | None = None,
@@ -556,6 +777,45 @@ def apply_client_preferences(
         automation_backend if automation_backend is not None else current["automation_backend"],
         automation_enabled=merged["automation_enabled"],
     )
+    raw_provider_runtime = (
+        provider_runtime
+        if provider_runtime is not None
+        else current.get("provider_runtime")
+    )
+    raw_provider_runtime = dict(raw_provider_runtime or {})
+    if selected_chat_provider is not None:
+        raw_provider_runtime["selected_chat_provider"] = selected_chat_provider
+        derived_chat_client = provider_to_client(selected_chat_provider)
+        if derived_chat_client:
+            merged["interactive_clients"][derived_chat_client] = True
+            merged["default_terminal_client"] = derived_chat_client
+    elif default_terminal_client is not None:
+        raw_provider_runtime["selected_chat_provider"] = client_to_provider(
+            merged["default_terminal_client"]
+        )
+    if automation_provider is not None:
+        raw_provider_runtime["automation_provider"] = automation_provider
+        derived_backend = provider_to_client(automation_provider)
+        if derived_backend:
+            merged["interactive_clients"][derived_backend] = True
+        merged["automation_backend"] = (
+            derived_backend if derived_backend else BACKEND_NONE
+        )
+    elif automation_backend is not None or automation_enabled is not None:
+        raw_provider_runtime["automation_provider"] = client_to_provider(
+            merged["automation_backend"]
+        ) if merged["automation_backend"] != BACKEND_NONE else PROVIDER_NONE
+    merged["provider_runtime"] = normalize_provider_runtime(
+        raw_provider_runtime,
+        default_terminal_client=merged["default_terminal_client"],
+        automation_backend=merged["automation_backend"],
+        automation_enabled=merged["automation_enabled"],
+    )
+    merged["automation_backend"] = merged["provider_runtime"]["automation_backend"]
+    selected_client = provider_to_client(merged["provider_runtime"].get("selected_chat_provider"))
+    if selected_client in TERMINAL_CLIENT_KEYS:
+        merged["interactive_clients"][selected_client] = True
+        merged["default_terminal_client"] = selected_client
     merged["automation_user_override"] = normalize_automation_user_override(
         automation_user_override
         if automation_user_override is not None
@@ -597,6 +857,9 @@ def save_client_preferences(
     last_terminal_client: str | None = None,
     automation_enabled=None,
     automation_backend: str | None = None,
+    provider_runtime: dict | None = None,
+    selected_chat_provider: str | None = None,
+    automation_provider: str | None = None,
     automation_user_override: bool | None = None,
     client_runtime_profiles: dict | None = None,
     automation_task_profiles: dict | None = None,
@@ -611,6 +874,9 @@ def save_client_preferences(
         last_terminal_client=last_terminal_client,
         automation_enabled=automation_enabled,
         automation_backend=automation_backend,
+        provider_runtime=provider_runtime,
+        selected_chat_provider=selected_chat_provider,
+        automation_provider=automation_provider,
         automation_user_override=automation_user_override,
         client_runtime_profiles=client_runtime_profiles,
         automation_task_profiles=automation_task_profiles,
@@ -666,7 +932,11 @@ def detect_installed_clients(user_home: str | os.PathLike[str] | None = None) ->
         claude_bin = _managed_claude_binary(home)
     else:
         claude_bin = os.environ.get("CLAUDE_BIN", "").strip() or _which_with_nvm("claude", home)
-    codex_bin = os.environ.get("CODEX_BIN", "").strip() or _which_with_nvm("codex", home)
+    if _desktop_product_requested(home):
+        managed_codex_bin = _managed_codex_binary(home)
+        codex_bin = managed_codex_bin if managed_codex_bin and _managed_codex_vendor_present(home) else ""
+    else:
+        codex_bin = os.environ.get("CODEX_BIN", "").strip() or _which_with_nvm("codex", home)
 
     if sys.platform == "darwin":
         desktop_app = next(
@@ -714,6 +984,28 @@ def resolve_terminal_client(requested: str | None = None, *, preferences: dict |
     )
 
 
+def resolve_selected_chat_provider(preferences: dict | None = None) -> str:
+    normalized = preferences or load_client_preferences()
+    provider_runtime = normalize_provider_runtime(
+        normalized.get("provider_runtime"),
+        default_terminal_client=normalized.get("default_terminal_client", CLIENT_CLAUDE_CODE),
+        automation_backend=normalized.get("automation_backend", CLIENT_CLAUDE_CODE),
+        automation_enabled=normalized.get("automation_enabled", True),
+    )
+    return provider_runtime["selected_chat_provider"]
+
+
+def resolve_automation_provider(preferences: dict | None = None) -> str:
+    normalized = preferences or load_client_preferences()
+    provider_runtime = normalize_provider_runtime(
+        normalized.get("provider_runtime"),
+        default_terminal_client=normalized.get("default_terminal_client", CLIENT_CLAUDE_CODE),
+        automation_backend=normalized.get("automation_backend", CLIENT_CLAUDE_CODE),
+        automation_enabled=normalized.get("automation_enabled", True),
+    )
+    return provider_runtime["automation_provider"]
+
+
 def resolve_user_model(preferences: dict | None = None) -> str:
     """Return the single model the user has configured.