aria-code 0.167.0__py3-none-win_amd64.whl

aria_code/apps/cli/model_probe.py

@@ -0,0 +1,169 @@
+"""Explicit model diagnostics using the selected transport, without file tools."""
+from __future__ import annotations
+
+import argparse
+import asyncio
+from dataclasses import asdict, dataclass
+import json
+import time
+
+from aria_code.apps.cli.providers.chat_routing import first_round_route
+from aria_code.packages.aria_services.provider_health import classify_provider_error
+
+
+@dataclass(frozen=True)
+class ModelProbe:
+    model: str
+    route: str
+    success: bool
+    category: str
+    message: str
+    duration_ms: int
+    text_verified: bool = False
+    tools_verified: bool = False
+    provider: str = ""
+    first_token_ms: int | None = None
+    suggestion: str = ""
+    schema: str = "aria.model_probe.v1"
+
+    def to_dict(self) -> dict:
+        return asdict(self)
+
+
+_PROBE_TOOL = {"type": "function", "function": {
+    "name": "aria_probe_ping",
+    "description": "A diagnostic echo with no file access or side effects.",
+    "parameters": {"type": "object", "properties": {"echo": {"type": "string"}}, "required": ["echo"]},
+}}
+
+
+async def probe_model(config: dict, api_url: str = "", *, tools: bool = False,
+                      timeout: float = 30) -> ModelProbe:
+    """One text request, optionally one inert tool call and its round trip.
+
+    Do not use the agent gateway: its provider fallback and project tools can
+    hide a broken primary route or perform work. Never change saved settings.
+    """
+    from aria_code.apps.cli.providers.base import AriaSSEProvider, ConfiguredProvider, OllamaProvider
+    from aria_code.packages.aria_sdk.streaming import stream_provider_result
+
+    cfg = dict(config)
+    model = str(cfg.get("model") or "")
+    route = first_round_route(model, cfg, api_url)
+    started = time.monotonic()
+    cancel = asyncio.Event()
+    text_ok = tool_ok = False
+    provider_name = ""
+    first_token = None
+
+    def token(_text):
+        nonlocal first_token
+        if _text.strip() and first_token is None:
+            first_token = round((time.monotonic() - started) * 1000)
+
+    def result(ok, category, message, suggestion=""):
+        return ModelProbe(model, route, ok, category, message,
+                          round((time.monotonic() - started) * 1000),
+                          text_ok, tool_ok, provider_name, first_token, suggestion)
+
+    def failed(error):
+        raw = str(error or "empty_response")
+        if "ollama_model_unavailable:" in raw:
+            return result(False, "model_unavailable", "The selected Ollama model is not installed or could not be verified.",
+                          "Run ollama list and /model; install the exact model with ollama pull <model> if needed.")
+        if "backend_local_tools_unsupported" in raw or "tool_protocol" in raw:
+            return result(False, "protocol_unsupported", "Backend does not support the local tool protocol.",
+                          "Update the backend protocol or use a direct provider for local project tasks.")
+        issue = classify_provider_error(provider_name or route, error)
+        suggestions = {
+            "auth": "Check credentials and project permissions; for Google Cloud, verify gcloud/ADC authorization.",
+            "configuration": "Set your Google Cloud project: /config set gcp_project=<project-id> or GOOGLE_CLOUD_PROJECT.",
+            "model_unavailable": "Check the selected model ID, project and serving region with /model.",
+            "rate_limited": "Wait for the quota cooldown or check the provider quota.",
+            "timeout": "Check network and provider latency; increase --timeout if needed.",
+            "no_data": "The selected route returned no visible text; check its streaming/model configuration.",
+        }
+        return result(False, issue.category, issue.message,
+                      suggestions.get(issue.category, "Check the selected provider and connection settings."))
+
+    def provider(local_tools=False):
+        if route == "cloud":
+            return AriaSSEProvider(api_url, model, auth_token=cfg.get("auth_token"),
+                                   use_react_gateway=bool(cfg.get("arthera_react_gateway")),
+                                   local_tools=local_tools)
+        if route == "ollama":
+            return OllamaProvider(str(cfg.get("ollama_url") or "http://localhost:11434"), model,
+                                  system_override="Only perform the requested diagnostic.",
+                                  show_market_prefetch_status=False, include_ambient_context=False)
+        return ConfiguredProvider(cfg, model)
+
+    async def run():
+        nonlocal text_ok, tool_ok, provider_name
+        reply = await stream_provider_result(provider(), "Reply with the single word READY.", [],
+                                             tools=[], cancel_event=cancel, on_token=token)
+        provider_name = str(reply.get("provider") or route)
+        if not reply.get("success") or not str(reply.get("response") or "").strip():
+            return failed(reply.get("error") or "empty_response")
+        text_ok = True
+        if not tools:
+            return result(True, "ok", "Selected model returned visible text.")
+        diagnostic = provider(local_tools=True)
+        request = "Call aria_probe_ping exactly once with echo='READY'. Do not answer in text before calling it."
+        call = await stream_provider_result(diagnostic, request, [], tools=[_PROBE_TOOL], cancel_event=cancel)
+        if not call.get("success"):
+            return failed(call.get("error"))
+        calls = list(call.get("tool_calls_pending") or [])
+        if len(calls) != 1 or calls[0].get("tool") != "aria_probe_ping" or calls[0].get("params") != {"echo": "READY"}:
+            return result(False, "tool_protocol", "Model did not return the requested diagnostic tool call.",
+                          "Check that this model and transport support function calling.")
+        history = [{"role": "user", "content": request},
+                   {"role": "assistant", "content": "", "tool_calls": [{"id": "aria-probe-1", "type": "function",
+                    "function": {"name": "aria_probe_ping", "arguments": '{"echo":"READY"}'}}]},
+                   {"role": "tool", "name": "aria_probe_ping", "tool_call_id": "aria-probe-1", "content": '{"echo":"READY"}'}]
+        reply = await stream_provider_result(diagnostic, "The diagnostic tool returned READY. Reply READY.", history,
+                                             tools=[], cancel_event=cancel)
+        if not reply.get("success") or not str(reply.get("response") or "").strip():
+            return failed(reply.get("error") or "empty_response")
+        tool_ok = True
+        return result(True, "ok", "Selected model returned text and completed the diagnostic tool round trip.")
+
+    try:
+        return await asyncio.wait_for(run(), timeout=timeout)
+    except asyncio.TimeoutError:
+        return failed("model probe timed out")
+    except Exception as exc:
+        return failed(exc)
+    finally:
+        cancel.set()
+
+
+def main(argv=None) -> int:
+    """Fast standalone equivalent of /health --model; no REPL or agent import."""
+    parser = argparse.ArgumentParser(prog="aria health", description="Probe the selected model without accessing project files")
+    parser.add_argument("--model", action="store_true", help="Send a short text generation request")
+    parser.add_argument("--tools", action="store_true", help="Also verify an inert tool call and its result")
+    parser.add_argument("--model-id", help="Probe this model without changing your saved selection")
+    parser.add_argument("--timeout", type=float, default=30, help="Total probe deadline in seconds (1–60)")
+    parser.add_argument("--json", action="store_true")
+    args = parser.parse_args(argv)
+    if not 1 <= args.timeout <= 60:
+        parser.error("--timeout must be between 1 and 60 seconds")
+    from aria_code.apps.cli.bootstrap import initialize_cli_environment, default_config, runtime_paths
+    from aria_code.apps.cli.config_store import load_cli_config
+
+    initialize_cli_environment()
+    cfg = load_cli_config(runtime_paths(), default_config())
+    if args.model_id:
+        cfg["model"] = args.model_id
+    if not (args.model or args.tools):
+        report = ModelProbe(str(cfg.get("model") or ""), first_round_route(str(cfg.get("model") or ""), cfg, cfg.get("api_url")),
+                            False, "not_probed", "Run aria health --model to test generation; add --tools to test function calling.", 0)
+    else:
+        report = asyncio.run(probe_model(cfg, str(cfg.get("api_url") or ""), tools=args.tools, timeout=args.timeout))
+    if args.json:
+        print(json.dumps(report.to_dict(), ensure_ascii=False))
+    else:
+        print(f"{report.model} · {report.route} · {report.category}: {report.message}")
+        if report.suggestion:
+            print(report.suggestion)
+    return 0 if report.success else (2 if report.category == "not_probed" else 1)

aria_code/apps/cli/model_retirement.py

@@ -0,0 +1,65 @@
+"""Models Google has retired, and what Aria moves their users to.
+
+Google's Vertex AI lifecycle page retires gemini-2.5-pro, -flash and
+-flash-lite on 20 October 2026 (the release notes give 16 October, so plan
+for the earlier date); the Gemini API already admits only users who have
+used 2.5 before. gemini-2.0-flash and -flash-lite shut down on 1 June 2026,
+and every 1.5 model in 2025. A saved config that still names one of them
+would fail on every request with an error that does not say why.
+
+So a retired id is replaced when the config is loaded, and the replacement
+is written back so it happens once: a stable model, not a short-term one,
+so an install that is rarely updated does not break again within months.
+The replacements follow Google's recommendations; 2.5 Flash moves to 3.8
+Flash rather than a Lite model so the user loses nothing in capability.
+"""
+
+from __future__ import annotations
+
+import re
+
+# bare id -> bare replacement
+RETIRED: dict[str, str] = {
+    "gemini-2.5-pro": "gemini-3.8-flash",
+    "gemini-2.5-flash": "gemini-3.8-flash",
+    "gemini-2.5-flash-lite": "gemini-3.1-flash-lite",
+    "gemini-2.0-flash": "gemini-3.8-flash",
+    "gemini-2.0-flash-lite": "gemini-3.1-flash-lite",
+    "gemini-1.5-pro": "gemini-3.8-flash",
+    "gemini-1.5-flash": "gemini-3.8-flash",
+    "gemini-1.0-pro": "gemini-3.8-flash",
+    # The previous default. Google deprecated it on 2026-10-08 and routes it to 3.6 Flash.
+    "gemini-3.5-flash": "gemini-3.8-flash",
+}
+
+# Dated, versioned and preview spellings of the same models:
+# gemini-2.5-pro-preview-06-05, gemini-2.0-flash-001, gemini-1.5-pro-latest.
+_SUFFIX = re.compile(r"(-preview(-[\w-]+)?|-exp(-[\w-]+)?|-latest|-\d{3}|-\d{2}-\d{2}|-\d{2}-\d{4})+$")
+
+
+def retired_replacement(model: str) -> str | None:
+    """The id to use instead of *model*, keeping its provider prefix; None if it is not retired."""
+    if not model:
+        return None
+    text = str(model).strip()
+    prefix, _, bare = text.rpartition("/")
+    key = _SUFFIX.sub("", bare.lower())
+    replacement = RETIRED.get(key)
+    if replacement is None:
+        return None
+    return f"{prefix}/{replacement}" if prefix else replacement
+
+
+def migrate_config(config: dict, keys: tuple[str, ...] = ("model",)) -> list[tuple[str, str, str]]:
+    """Replace retired model ids in *config* in place; return (key, old, new) for each."""
+    changes = []
+    for key in keys:
+        old = config.get(key)
+        new = retired_replacement(old) if isinstance(old, str) else None
+        if new:
+            config[key] = new
+            changes.append((key, old, new))
+    return changes
+
+
+__all__ = ["RETIRED", "migrate_config", "retired_replacement"]

aria_code/apps/cli/native_branding.py

@@ -0,0 +1,12 @@
+"""Legacy mascot spans for native frontends predating named Rust artwork."""
+from __future__ import annotations
+
+import os
+
+
+def robot_rows(*, hidden: bool = False) -> list:
+    if hidden or os.environ.get("ARIA_ROBOT_RENDER", "").strip().lower() == "off":
+        return []
+    from aria_code.ui.robot import ROBOT_ROW_COUNT, get_robot_row
+    return [[{"style": style, "text": text} for style, text in get_robot_row(0, row)]
+            for row in range(ROBOT_ROW_COUNT)]

aria_code/apps/cli/native_bridge.py

@@ -0,0 +1,118 @@
+"""Experimental, workspace-confined JSON-RPC worker for the Rust CLI.
+
+The host selects the workspace and approves one named write via process flags.
+Request parameters never establish permissions. Existing CLI handlers retain
+their diff, change-store and verification behavior; stdout is protocol only.
+"""
+from __future__ import annotations
+
+import argparse
+import contextlib
+import json
+import sys
+from pathlib import Path
+from typing import Any
+
+MAX_MESSAGE = 1_048_576
+READ_TOOLS = frozenset({"read_file", "list_files", "search_code"})
+WRITE_TOOLS = frozenset({"write_file", "edit_file"})
+
+
+def error(code: int, message: str, request_id: Any = None) -> dict:
+    return {"jsonrpc": "2.0", "id": request_id, "error": {"code": code, "message": message}}
+
+
+def execute(name: str, arguments: dict, workspace: Path, approved_tool: str | None) -> dict:
+    from aria_code.runtime.approval import ApprovalDecision
+    from aria_code.runtime.tool_executor import ToolExecutor
+    from aria_code.runtime.tool_policy import check_tool_policy
+
+    if name not in READ_TOOLS | WRITE_TOOLS:
+        return {"success": False, "error": f"Tool not exposed by native bridge: {name}"}
+    verdict = check_tool_policy(name)
+    if verdict == "deny":
+        return {"success": False, "error": "Blocked by persistent tool policy"}
+    approved = name in WRITE_TOOLS and name == approved_tool
+    if verdict == "ask" and not approved:
+        return {"success": False, "error": "Tool requires explicit approval; use the interactive Python CLI"}
+    if name in WRITE_TOOLS and not approved:
+        return {"success": False, "error": "Writes require host --approve-write for this invocation"}
+    def handler(params: dict) -> dict:
+        # Load UI-dependent write code only after ToolExecutor grants the path.
+        if name in READ_TOOLS:
+            from aria_code.apps.cli.tools import file_tools
+            return getattr(file_tools, "tool_" + name)(params)
+        from aria_code.apps.cli.tools import write_tools
+        cli = write_tools._ac()
+        console = getattr(cli, "console", None)
+        previous = console.file if console is not None else None
+        try:
+            if console is not None:
+                console.file = sys.stderr
+            return getattr(write_tools, "tool_" + name)(params)
+        finally:
+            if console is not None:
+                console.file = previous
+    executor = ToolExecutor(
+        {name: (handler,)},
+        config={"workspace_root": str(workspace), "permission_mode": "workspace-write" if approved else "read-only"},
+        execution_context=lambda: {"_workspace_restricted": True},
+    )
+    decision = ApprovalDecision.allow(user_approved=True, tool_scope=name) if approved else None
+    return executor.execute_local(name, arguments, approval=decision)
+
+
+def dispatch(request: Any, workspace: Path, approved_tool: str | None = None) -> dict | None:
+    if not isinstance(request, dict):
+        return error(-32600, "Expected a single JSON-RPC request object")
+    request_id = request.get("id")
+    valid_id = request_id is None or isinstance(request_id, str) or type(request_id) is int
+    if request.get("jsonrpc") != "2.0" or not isinstance(request.get("method"), str) or not valid_id:
+        return error(-32600, "Invalid JSON-RPC request")
+    # This bridge only executes requests with an ID. Notifications never cause
+    # file changes and never produce a response, including unknown methods.
+    if "id" not in request:
+        return None
+    if request["method"] != "tools.call":
+        return error(-32601, "Method not found", request_id)
+    params = request.get("params")
+    if not isinstance(params, dict) or not isinstance(params.get("name"), str) or not isinstance(params.get("arguments"), dict):
+        return error(-32602, "Expected name and arguments object", request_id)
+    try:
+        with contextlib.redirect_stdout(sys.stderr):
+            result = execute(params["name"], params["arguments"], workspace, approved_tool)
+        return {"jsonrpc": "2.0", "id": request_id, "result": result}
+    except Exception as exc:
+        return error(-32603, f"Python tool failed: {exc}", request_id)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--workspace", type=Path, required=True)
+    parser.add_argument("--approve-tool", choices=sorted(WRITE_TOOLS))
+    args = parser.parse_args()
+    workspace = args.workspace.expanduser().resolve(strict=True)
+    if not workspace.is_dir():
+        parser.error("workspace must be a directory")
+    # One request per process bounds trace memory and approval lifetime. Read
+    # size is bounded before JSON decoding; no unbounded readline allocation.
+    raw = sys.stdin.buffer.readline(MAX_MESSAGE + 1)
+    if len(raw) > MAX_MESSAGE:
+        response = error(-32600, "Request exceeds 1 MiB")
+    else:
+        try:
+            request = json.loads(raw)
+        except (ValueError, UnicodeDecodeError):
+            response = error(-32700, "Parse error")
+        else:
+            response = dispatch(request, workspace, args.approve_tool)
+    if response is not None:
+        encoded = json.dumps(response, ensure_ascii=True, allow_nan=False).encode("ascii")
+        if len(encoded) + 1 > MAX_MESSAGE:
+            encoded = json.dumps(error(-32603, "Response exceeds 1 MiB", response["id"])).encode("ascii")
+        sys.stdout.buffer.write(encoded + b"\n")
+        sys.stdout.buffer.flush()
+
+
+if __name__ == "__main__":
+    main()

aria_code/apps/cli/native_entry.py

@@ -0,0 +1,58 @@
+"""Lightweight native frontend bootstrap and frozen worker entrypoints.
+
+Rust owns the terminal; Python remains the provider/tool application service.
+Private worker modes are dispatched before importing the legacy CLI. Setting
+ARIA_FRONTEND=python explicitly keeps the original interface available.
+"""
+from __future__ import annotations
+
+import os
+import subprocess
+import sys
+
+
+def dispatch_worker() -> None:
+    if sys.argv[1:2] != ["--aria-worker"]:
+        return
+    if len(sys.argv) < 3:
+        raise SystemExit("Missing worker mode")
+    mode = sys.argv[2]
+    del sys.argv[1:3]
+    os.environ["ARIA_FRONTEND"] = "python"
+    # The host assigns process containment before acknowledging startup.
+    if mode in ("app", "stream") and sys.stdin.buffer.read(1) != b"\n":
+        raise SystemExit(2)
+    if mode == "app":
+        from aria_code.apps.cli.app_server import main
+    elif mode == "bridge":
+        from aria_code.apps.cli.native_bridge import main
+    elif mode in ("cli", "stream"):
+        from aria_code.apps.cli.main import main
+    else:
+        raise SystemExit("Unknown worker mode")
+    main()
+    raise SystemExit(0)
+
+
+def maybe_native() -> None:
+    if os.environ.get("ARIA_FRONTEND", "").lower() == "python":
+        return
+    # Never change pipe/headless output or load a UI in a non-terminal.
+    if not (sys.stdin.isatty() and sys.stdout.isatty()):
+        return
+    from aria_code.runtime.native_index import native_binary
+    binary = native_binary()
+    if not binary:
+        return  # Pure Python wheels remain usable without a Rust installation.
+    try:
+        capability = subprocess.run([binary, "--entry-protocol"], capture_output=True,
+                                    timeout=3, check=False)
+        if capability.returncode or capability.stdout.strip() != b"1":
+            return  # Old opt-in prototypes do not implement the formal entry.
+    except (OSError, subprocess.SubprocessError):
+        return
+    env = dict(os.environ, ARIA_PYTHON=sys.executable)
+    if os.name != "nt":
+        os.execve(binary, [binary, "--app", *sys.argv[1:]], env)
+    result = subprocess.run([binary, "--app", *sys.argv[1:]], env=env, check=False)
+    raise SystemExit(result.returncode)