nexo-brain 7.25.6 → 7.27.0

package/src/agent_runner.py

@@ -24,8 +24,12 @@ from client_preferences import (
     BACKEND_NONE,
     CLIENT_CLAUDE_CODE,
     CLIENT_CODEX,
+    client_to_provider,
     TERMINAL_CLIENT_KEYS,
     load_client_preferences,
+    _desktop_product_requested,
+    _managed_codex_binary,
+    _managed_codex_vendor_present,
     normalize_client_key,
     resolve_automation_backend,
     resolve_client_runtime_profile,
@@ -40,6 +44,7 @@ CLAUDE_LEGACY_MODEL_HINTS = {"opus", "sonnet"}
 MODEL_PRICING_USD_PER_1M = {
     # Pricing snapshot used only when the backend does not return explicit cost.
     # Codex model names map to the current GPT-5 family pricing.
+    "gpt-5.5": {"input": 1.25, "cached_input": 0.125, "output": 10.0},
     "gpt-5.4": {"input": 1.25, "cached_input": 0.125, "output": 10.0},
     "gpt-5.4-mini": {"input": 0.25, "cached_input": 0.025, "output": 2.0},
 }
@@ -54,11 +59,16 @@ class TerminalClientUnavailableError(AgentRunnerError):
 class AutomationBackendUnavailableError(AgentRunnerError):
     """Raised when the configured automation backend is unavailable."""
 
+
+def _automation_provider_for_backend(backend: str) -> str:
+    return client_to_provider(backend) or ""
+
 def _canonical_pricing_model(model: str) -> str:
     lowered = str(model or "").strip().lower()
     lowered = lowered.split("[", 1)[0]
     aliases = {
-        "gpt-5": "gpt-5.4",
+        "gpt-5": "gpt-5.5",
+        "gpt-5.5": "gpt-5.5",
         "gpt-5.4": "gpt-5.4",
         "gpt-5-mini": "gpt-5.4-mini",
         "gpt-5.4-mini": "gpt-5.4-mini",
@@ -199,6 +209,7 @@ def _record_automation_start(
     *,
     caller: str,
     backend: str,
+    provider: str = "",
     session_type: str,
     task_profile: str,
     model: str,
@@ -225,14 +236,15 @@ def _record_automation_start(
         cur = conn.execute(
             """
             INSERT INTO automation_runs (
-                caller, backend, session_type, task_profile, model,
+                caller, backend, provider, session_type, task_profile, model,
                 reasoning_effort, resonance_tier, cwd, output_format,
                 prompt_chars, status, started_at, pid
-            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'running', datetime('now'), ?)
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'running', datetime('now'), ?)
             """,
             (
                 caller or "",
                 backend,
+                provider or _automation_provider_for_backend(backend),
                 session_type or "headless",
                 task_profile or "default",
                 model or "",
@@ -339,6 +351,7 @@ def _record_automation_end(
 def _record_automation_run(
     *,
     backend: str,
+    provider: str = "",
     task_profile: str,
     model: str,
     reasoning_effort: str,
@@ -359,6 +372,7 @@ def _record_automation_run(
     row_id, err = _record_automation_start(
         caller=caller,
         backend=backend,
+        provider=provider or _automation_provider_for_backend(backend),
         session_type=session_type,
         task_profile=task_profile,
         model=model,
@@ -378,14 +392,57 @@ def _record_automation_run(
     )
 
 
+def _record_backend_unavailable(
+    *,
+    backend: str,
+    caller: str,
+    cwd: Path,
+    prompt: str,
+) -> None:
+    profile = resolve_client_runtime_profile(backend)
+    _record_automation_run(
+        backend=backend,
+        provider=_automation_provider_for_backend(backend),
+        task_profile="default",
+        model=profile.get("model", ""),
+        reasoning_effort=profile.get("reasoning_effort", ""),
+        cwd=cwd,
+        output_format="text",
+        prompt=prompt,
+        returncode=2,
+        duration_ms=0,
+        telemetry={
+            "telemetry_source": "backend_unavailable",
+            "cost_source": "missing",
+            "usage": {},
+            "warnings": ["backend_unavailable", "fallback_blocked"],
+            "raw": {
+                "event": "backend_unavailable",
+                "backend": backend,
+                "provider": _automation_provider_for_backend(backend),
+                "fallback_policy": "fail_closed",
+            },
+        },
+        caller=caller,
+        session_type="headless",
+    )
+
+
 def _resolve_claude_cli() -> str:
     return _shared_resolve_claude_cli()
 
 
 def _resolve_codex_cli() -> str:
+    home = Path.home()
+    if _desktop_product_requested(home):
+        managed_path = _managed_codex_binary(home)
+        return managed_path if managed_path and _managed_codex_vendor_present(home) else ""
     env_path = os.environ.get("CODEX_BIN", "").strip()
     if env_path and Path(env_path).exists():
         return env_path
+    managed_path = _managed_codex_binary(home)
+    if managed_path and _managed_codex_vendor_present(home):
+        return managed_path
     return shutil.which("codex") or ""
 
 
@@ -790,6 +847,7 @@ def run_automation_interactive(
     row_id, _record_err = _record_automation_start(
         caller=caller,
         backend=resolved_client,
+        provider=_automation_provider_for_backend(resolved_client),
         session_type=session_type,
         task_profile="",
         model="",
@@ -905,15 +963,6 @@ def _backend_is_available(backend: str) -> bool:
 
 
 def _resolve_available_backend(selected_backend: str, *, preferences: dict | None = None) -> str:
-    if _backend_is_available(selected_backend):
-        return selected_backend
-    prefs = preferences or load_client_preferences()
-    preferred = resolve_automation_backend(preferences=prefs)
-    for candidate in (preferred, CLIENT_CLAUDE_CODE, CLIENT_CODEX):
-        if candidate == selected_backend or candidate == BACKEND_NONE:
-            continue
-        if _backend_is_available(candidate):
-            return candidate
     return selected_backend
 
 
@@ -1011,7 +1060,7 @@ _ANTHROPIC_API_KEY_SEARCH_PATHS = (
 
 
 def _resolve_anthropic_api_key() -> str:
-    """Locate an Anthropic API key for bare-mode invocations.
+    """Locate a legacy Anthropic API key for opt-in bare-mode invocations.
 
     ``claude --bare`` skips macOS Keychain auth entirely, so the child
     must find the API key in ``ANTHROPIC_API_KEY`` or via ``apiKeyHelper``.
@@ -1039,15 +1088,16 @@ def _resolve_anthropic_api_key() -> str:
     return ""
 
 
-# Callers for which bare_mode=True is safe. The child's only allowed_tools
-# must be file/grep/shell (no ``mcp__nexo__*``), otherwise --bare's opt-out
-# of plugin sync / MCP bootstrap breaks the run. Extract/synthesize fit
-# this profile: they read transcripts + shared-context and emit JSON, no
-# NEXO tool calls.
-BARE_MODE_SAFE_CALLERS: frozenset[str] = frozenset({
-    "deep-sleep/extract",
-    "deep-sleep/synthesize",
-})
+def _allow_anthropic_api_key_bare_mode() -> bool:
+    value = os.environ.get("NEXO_ALLOW_ANTHROPIC_API_BARE", "").strip().lower()
+    return value in {"1", "true", "yes", "on"}
+
+
+# v7.26 provider-runtime contract: Desktop-managed automation must use the
+# selected account runtime (Claude Code or Codex), not an Anthropic API key
+# side path. Bare mode remains a hidden legacy opt-in for controlled local
+# experiments only via NEXO_ALLOW_ANTHROPIC_API_BARE=1.
+BARE_MODE_SAFE_CALLERS: frozenset[str] = frozenset()
 
 # Execution contracts keep background agents disciplined without polluting
 # machine-only child calls that must return strict JSON.
@@ -1153,6 +1203,17 @@ def run_automation_prompt(
     if selected_backend == BACKEND_NONE:
         raise AutomationBackendUnavailableError("Automation backend is disabled in config.")
     selected_backend = _resolve_available_backend(selected_backend, preferences=prefs)
+    if not _backend_is_available(selected_backend):
+        cwd_path = Path(cwd).expanduser().resolve() if cwd else Path.cwd()
+        _record_backend_unavailable(
+            backend=selected_backend,
+            caller=caller,
+            cwd=cwd_path,
+            prompt=prompt,
+        )
+        raise AutomationBackendUnavailableError(
+            f"{selected_backend} automation backend selected but launcher is not installed; fallback blocked."
+        )
 
     # Resonance map decides (model, effort) for every call. ``caller`` is
     # MANDATORY — every script that invokes the automation backend must be
@@ -1256,13 +1317,13 @@ def run_automation_prompt(
         # completes in seconds.
         #
         # Selection rules:
-        #   - bare_mode=True explicit → trust the caller.
+        #   - bare_mode=True explicit → allow only when the legacy API-key
+        #     escape hatch is enabled.
         #   - bare_mode=None (default) + caller in BARE_MODE_SAFE_CALLERS
-        #     → auto-enable.
+        #     → auto-enable. v7.26 keeps this set empty for provider parity.
         #   - bare_mode=False → never.
-        #   - --bare disables keychain auth, so we must provide an
-        #     ANTHROPIC_API_KEY. If one cannot be located, fall back to
-        #     normal mode with a warning on stderr rather than failing.
+        #   - --bare disables keychain auth, so the legacy path requires
+        #     ANTHROPIC_API_KEY. If disabled or missing, use normal account auth.
         resolved_bare = False
         if bare_mode is True:
             resolved_bare = True
@@ -1271,12 +1332,14 @@ def run_automation_prompt(
 
         bare_api_key = ""
         if resolved_bare:
-            bare_api_key = _resolve_anthropic_api_key()
-            if not bare_api_key:
-                # Silent fallback: we would rather take the slower path
-                # than force the caller to fail-closed on an env quirk.
+            if not _allow_anthropic_api_key_bare_mode():
                 resolved_bare = False
-
+            else:
+                bare_api_key = _resolve_anthropic_api_key()
+                if not bare_api_key:
+                    # Silent fallback: we would rather take the slower path
+                    # than force the caller to fail-closed on an env quirk.
+                    resolved_bare = False
         # Headless claude -p does NOT reliably honour permissions.allow from
         # settings.json for MCP tool calls — it can stall waiting for an
         # approval that will never come in non-interactive mode. All NEXO
@@ -1293,6 +1356,8 @@ def run_automation_prompt(
             run_env = dict(run_env)
             run_env["ANTHROPIC_API_KEY"] = bare_api_key
         else:
+            run_env = dict(run_env)
+            run_env.pop("ANTHROPIC_API_KEY", None)
             cmd.append("--dangerously-skip-permissions")
         if resolved_model:
             cmd.extend(["--model", resolved_model])
@@ -1342,6 +1407,7 @@ def run_automation_prompt(
         telemetry["automation_contract"] = automation_contract
         recorded, record_error = _record_automation_run(
             backend=selected_backend,
+            provider=_automation_provider_for_backend(selected_backend),
             task_profile=task_profile,
             model=resolved_model,
             reasoning_effort=resolved_effort,
@@ -1420,6 +1486,7 @@ def run_automation_prompt(
             telemetry["automation_contract"] = automation_contract
             recorded, record_error = _record_automation_run(
                 backend=selected_backend,
+                provider=_automation_provider_for_backend(selected_backend),
                 task_profile=task_profile,
                 model=resolved_model,
                 reasoning_effort=resolved_effort,

package/src/call_model_raw.py

@@ -260,7 +260,7 @@ def call_model_raw(
     Parameters follow the Fase 2 plan doc 1 spec:
 
         prompt          — the user-role text (English or the model's default).
-        tier            — resonance tier; default "muy_bajo" → Haiku / gpt-5.4-mini.
+        tier            — resonance tier; default "muy_bajo" → Haiku / gpt-5.5 low.
         caller          — resonance caller label. Must be registered in
                           resonance_map.SYSTEM_OWNED_CALLERS. Default
                           "enforcer_classifier".

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":