aria-code 0.167.0__py3-none-win_amd64.whl

aria_code/apps/cli/providers/chat_routing.py

@@ -0,0 +1,139 @@
+"""Provider routing + fallback DECISIONS for the chat loop (pure, testable).
+
+Extracted from ``aria_cli.send_message`` as the keystone for the documented
+runtime next step ("route the whole CLI tool loop through run_agent"). The
+*decision* of which provider a round uses, and whether to fall back, is pure
+logic; pulling it out of the streaming machinery lets it be unit-tested and
+reused as a ``provider_fn`` selector without touching the live REPL path.
+
+Routing rules (mirrors send_message):
+  • backend_chat                     → Aria SSE backend
+  • local_provider=ollama            → Ollama (local or Ollama Cloud)
+  • any other explicit provider      → configured local/API provider
+"""
+
+from __future__ import annotations
+
+from typing import Callable, Optional
+
+
+PROVIDER_ALIASES = {
+    "lm-studio": "lmstudio",
+    "llama.cpp": "llamacpp",
+    "llama-cpp": "llamacpp",
+    "claude": "anthropic",
+    "chatgpt": "openai",
+    "openai-chatgpt": "openai",
+    "gemini": "google",
+    "grok": "xai",
+}
+
+
+def normalize_provider_name(provider: str) -> str:
+    normalized = str(provider or "").strip().lower()
+    return PROVIDER_ALIASES.get(normalized, normalized)
+
+
+def is_cloud_model(model: str) -> bool:
+    """Cloud models are provider-prefixed, e.g. ``openai/gpt-4.5``, ``anthropic/…``."""
+    return "/" in (model or "")
+
+
+def is_ollama_model(model: str) -> bool:
+    """Ollama models have no ``/`` (``gpt-oss:120b-cloud``, ``deepseek-r1:14b``)."""
+    return "/" not in (model or "")
+
+
+def force_backend(config: dict, api_url: Optional[str]) -> bool:
+    """backend_chat=True routes ALL chat through the self-hosted backend (which
+    proxies to its own Ollama + collects training data), requiring an api_url."""
+    return bool(config.get("backend_chat")) and bool(api_url)
+
+
+# Prefixes that genuinely name a provider.  Checked explicitly because a slash
+# in a model id does not always mean a provider: Ollama serves namespaced
+# community models such as "hf.co/someone/qwen", whose first segment is a host,
+# not a backend to route to.
+KNOWN_MODEL_PROVIDERS = frozenset({
+    "ollama", "openai", "anthropic", "google", "xai", "deepseek", "groq",
+    "together", "dashscope", "lmstudio", "siliconflow", "moonshot", "zhipu",
+    "mistral", "cohere", "perplexity", "baidu", "ernie", "qianfan",
+    "bytedance", "doubao", "ark", "minimax", "stepfun", "01ai", "yi",
+    "vertexai", "vertex-ai", "google-genai",
+})
+
+
+def model_provider(model: str) -> str:
+    """Provider named by the model id itself, or "" when it names none.
+
+    Returns "" for bare Ollama names ("qwen2.5:7b") and for namespaced Ollama
+    models whose prefix is not a known provider ("hf.co/someone/qwen").
+    """
+    if not is_cloud_model(model):
+        return ""
+    candidate = normalize_provider_name(model.split("/", 1)[0])
+    return candidate if candidate in KNOWN_MODEL_PROVIDERS else ""
+
+
+def first_round_route(model: str, config: dict, api_url: Optional[str]) -> str:
+    """Return ``ollama`` | ``configured`` | ``cloud`` for the first round.
+
+    A provider-qualified model id ("google/gemini-2.5-pro") names its own
+    provider, and that wins over ``local_provider``.  It used to lose: the
+    default config ships ``model="gemini-pro"`` together with
+    ``local_provider="ollama"``, so every request for the flagship default
+    model was routed to Ollama instead — the status line reading "ollama"
+    beside a Gemini model name was reporting this honestly.
+
+    ``local_provider`` still decides for bare Ollama-style names
+    ("qwen2.5:7b", "gpt-oss:120b-cloud"), which is what it is there for.
+    """
+    if force_backend(config, api_url):
+        return "cloud"
+    provider = model_provider(model)
+    if not provider:
+        provider = normalize_provider_name(config.get("local_provider") or "") or "ollama"
+    return "ollama" if provider == "ollama" else "configured"
+
+
+def model_receives_local_tools(model: str, config: dict, api_url: Optional[str]) -> bool:
+    """Legacy chat has no local tools; client execution requires an opt-in
+    protocol acknowledgement. Direct inference carries the local schemas."""
+    return first_round_route(model, config, api_url) != "cloud" or bool(config.get("backend_local_tools"))
+
+
+def is_placeholder_response(
+    response: str,
+    token_count: int,
+    stub_detector: Optional[Callable[[str], bool]] = None,
+) -> bool:
+    """Detect empty or explicitly recognized stubs, never infer from length.
+
+    ``token_count`` remains in the signature for existing callers, but an SSE
+    final event can contain a valid answer without any streamed token events.
+    """
+    resp = response or ""
+    if not resp.strip():
+        return True
+    if stub_detector is not None and stub_detector(resp):
+        return True
+    # A short answer ("OK") or a long answer in one SSE final event is valid.
+    # Token counts describe transport chunking, not answer quality.
+    return False
+
+
+def should_fallback(route: str, result: dict, *, is_placeholder: bool) -> bool:
+    """Whether to run the local/cloud fallback chain after the primary round.
+
+    Keyed on the *route* (not the model name), so a forced-backend round that
+    genuinely succeeded does NOT fall back — which is the bug-free version of the
+    old ``_should_fallback`` that keyed on ``is_ollama_model`` and could discard a
+    good backend answer (causing a re-run / hang).
+    """
+    if result.get("fallback_allowed") is False or "ollama_model_unavailable:" in str(result.get("error", "")):
+        return False
+    if route in ("skip", "configured"):
+        return route == "skip"
+    if not result.get("success") and not result.get("cancelled"):
+        return True
+    return is_placeholder

aria_code/apps/cli/providers/collaboration.py

@@ -0,0 +1,98 @@
+"""Small, explicit multi-provider consultation helpers for the terminal.
+
+This module deliberately talks to provider *APIs*, not consumer desktop apps.
+ChatGPT Plus and Claude Pro sessions cannot safely be reused as API credentials.
+Keeping this boundary explicit prevents a CLI command from accidentally scraping
+browser sessions or consuming a provider that the user did not configure.
+"""
+from __future__ import annotations
+
+import asyncio
+from dataclasses import dataclass
+from typing import Any, Callable, Iterable
+
+
+@dataclass(frozen=True)
+class Collaborator:
+    alias: str
+    provider: str
+    default_model: str
+    label: str
+
+
+COLLABORATORS: dict[str, Collaborator] = {
+    "chatgpt": Collaborator("chatgpt", "openai", "gpt-4o-mini", "ChatGPT / OpenAI"),
+    "openai": Collaborator("chatgpt", "openai", "gpt-4o-mini", "ChatGPT / OpenAI"),
+    "claude": Collaborator("claude", "anthropic", "claude-3-5-haiku-latest", "Claude / Anthropic"),
+    "anthropic": Collaborator("claude", "anthropic", "claude-3-5-haiku-latest", "Claude / Anthropic"),
+}
+
+
+def resolve_collaborator(name: str, config: dict | None = None) -> Collaborator | None:
+    """Resolve user-friendly names and apply an optional configured model."""
+    target = COLLABORATORS.get(str(name or "").strip().lower())
+    if not target:
+        return None
+    configured_model = (config or {}).get(f"collab_{target.alias}_model")
+    if configured_model and str(configured_model).strip():
+        return Collaborator(target.alias, target.provider, str(configured_model).strip(), target.label)
+    return target
+
+
+def collaboration_readiness(config: dict, key_available: Callable[[str], bool]) -> list[dict[str, Any]]:
+    """Return deterministic readiness rows for the UI and tests."""
+    rows = []
+    for alias in ("chatgpt", "claude"):
+        target = resolve_collaborator(alias, config)
+        assert target is not None
+        rows.append({
+            "alias": target.alias,
+            "provider": target.provider,
+            "label": target.label,
+            "model": target.default_model,
+            "configured": bool(key_available(target.provider)),
+        })
+    return rows
+
+
+async def consult(
+    prompt: str,
+    targets: Iterable[Collaborator],
+    *,
+    get_provider: Callable[[str], Any],
+    message_factory: Callable[..., Any],
+    timeout: float = 60.0,
+) -> list[dict[str, str | bool]]:
+    """Ask configured collaborators concurrently without tools or chat history.
+
+    The caller decides which providers are configured.  Each response is kept
+    separate: this command is a transparent second-opinion panel, not a hidden
+    synthesis that could blur source attribution.
+    """
+    safe_prompt = str(prompt or "").strip()
+    if not safe_prompt:
+        return []
+
+    async def _one(target: Collaborator) -> dict[str, str | bool]:
+        try:
+            provider = get_provider(f"{target.provider}/{target.default_model}")
+            result = await asyncio.wait_for(
+                provider.complete([message_factory(role="user", content=safe_prompt)]),
+                timeout=timeout,
+            )
+            return {
+                "alias": target.alias,
+                "label": target.label,
+                "model": target.default_model,
+                "success": bool(result.get("success")),
+                "response": str(result.get("response") or ""),
+                "error": str(result.get("error") or ""),
+            }
+        except asyncio.TimeoutError:
+            return {"alias": target.alias, "label": target.label, "model": target.default_model,
+                    "success": False, "response": "", "error": f"timed out after {timeout:g}s"}
+        except Exception as exc:
+            return {"alias": target.alias, "label": target.label, "model": target.default_model,
+                    "success": False, "response": "", "error": str(exc)}
+
+    return await asyncio.gather(*(_one(target) for target in targets))

aria_code/apps/cli/providers/llm/__init__.py

@@ -0,0 +1 @@
+"""LLM streaming providers."""

aria_code/apps/cli/providers/llm/offline_responses.py

@@ -0,0 +1,68 @@
+"""Canned responses for when no model backend is reachable.
+
+These three lived in aria_cli's module globals and were borrowed by
+stream_ollama through the import-time rebind, so the fallback path — the SDK
+and the daemon, which never import aria_cli — died on them precisely when it
+needed them most: the Ollama-unavailable branch could not build its own
+"Ollama is unavailable" message.
+
+They are pure string/dict builders with no dependencies, and they belong with
+the provider whose failure mode they describe. aria_cli re-exports them under
+its original private names so nothing that borrows those names changes.
+"""
+
+from __future__ import annotations
+
+DEFAULT_OLLAMA_URL = "http://localhost:11434"
+
+GREETINGS = frozenset({
+    "hi", "hello", "hey", "你好", "您好", "嗨", "哈喽", "在吗",
+    "早上好", "下午好", "晚上好",
+})
+
+
+def is_simple_greeting(message: str) -> bool:
+    """True for a bare greeting that can be answered without a model."""
+    text = (message or "").strip().lower()
+    return text in GREETINGS or (
+        len(text) <= 8 and any(g in text for g in GREETINGS)
+    )
+
+
+def offline_greeting_response() -> dict:
+    """Answer a greeting when neither cloud nor local backend is reachable."""
+    return {
+        "success": True,
+        "response": (
+            "你好，我是 Aria Code。\n\n"
+            "当前云端模型不可用，且本地 Ollama 服务没有启动；简单问候可以直接响应。"
+            "如果要进行代码修改、市场分析或长文本推理，请先启动本地模型：\n\n"
+            "```bash\n"
+            "ollama serve\n"
+            "```\n\n"
+            "然后可用 `ollama list` 检查已安装模型，或运行 `/health` 查看 Aria Code 状态。"
+        ),
+        "provider": "builtin",
+        "usage": {"prompt_tokens": 0, "completion_tokens": 0, "thinking_tokens": 0},
+    }
+
+
+def ollama_unavailable_result(ollama_url: str, err: str = "") -> dict:
+    """The failure result for an unreachable local Ollama, with recovery steps."""
+    host = ollama_url or DEFAULT_OLLAMA_URL
+    detail = f"\n\nDetail: {err}" if err else ""
+    return {
+        "success": False,
+        "provider": "ollama",
+        "error": (
+            "Local Ollama is not reachable.\n\n"
+            f"Host: {host}\n"
+            "Start it in another terminal:\n\n"
+            "  ollama serve\n\n"
+            "Then verify:\n\n"
+            "  curl http://127.0.0.1:11434/api/tags\n"
+            "  ollama list\n\n"
+            "If you do not want local fallback, use a working cloud/API provider or disable local mode."
+            f"{detail}"
+        ),
+    }