aria-code 0.52.0__py3-none-any.whl

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

@@ -0,0 +1,60 @@
+"""Short-TTL response cache shared by the CLI and the extracted Ollama stream.
+
+These four names used to live in aria_cli.py and reach stream_ollama only
+through the module-global rebind in that file (see
+``_rebind_module_function_globals`` and the stream_ollama rebind site). Any
+caller that had not imported aria_cli first — the SDK and the daemon — got the
+un-rebound function instead and died on the first cache-eligible turn with
+``NameError: name '_cache_key' is not defined``.
+
+Keeping them here means both callers share one cache dict rather than each
+growing its own, and removes four of the borrowed globals that
+packages/aria_core/architecture.py tracks as debt.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import time
+
+__all__ = ["RESPONSE_CACHE", "RESPONSE_CACHE_TTL", "RESPONSE_CACHE_MAX_ENTRIES",
+           "cache_get", "cache_set", "cache_clear", "cache_key"]
+
+RESPONSE_CACHE: dict = {}   # key → (response_text, expire_ts)
+RESPONSE_CACHE_TTL = 60.0   # seconds
+RESPONSE_CACHE_MAX_ENTRIES = 200
+
+
+def cache_get(key: str) -> str | None:
+    """Return cached response text if still valid, else None."""
+    entry = RESPONSE_CACHE.get(key)
+    if entry and time.time() < entry[1]:
+        return entry[0]
+    return None
+
+
+def cache_set(key: str, value: str) -> None:
+    """Store response in cache with TTL expiry."""
+    RESPONSE_CACHE[key] = (value, time.time() + RESPONSE_CACHE_TTL)
+    # Keep cache small — evict expired entries when it grows large
+    if len(RESPONSE_CACHE) > RESPONSE_CACHE_MAX_ENTRIES:
+        now = time.time()
+        for k in list(RESPONSE_CACHE.keys()):
+            if RESPONSE_CACHE[k][1] < now:
+                del RESPONSE_CACHE[k]
+
+
+def cache_clear() -> None:
+    """Drop every cached response — for /clear and for test isolation.
+
+    v4.4.2 grew a second copy of this module at apps/cli/response_cache.py.
+    That copy is not taken: this one is already where the two callers share it,
+    and duplicating it would put two cache dicts behind one name. Only the
+    parts this one lacked came across.
+    """
+    RESPONSE_CACHE.clear()
+
+
+def cache_key(model: str, message: str) -> str:
+    raw = f"{model}::{message.strip().lower()}"
+    return hashlib.md5(raw.encode()).hexdigest()

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

@@ -0,0 +1,257 @@
+"""stream_chat — Aria cloud SSE provider extracted from aria_cli.py.
+
+Streams AI responses from the Aria backend via Server-Sent Events (SSE).
+Supports cancellation, thinking tokens, tool calls, retries, and usage stats.
+"""
+from __future__ import annotations
+
+import asyncio
+import json
+from typing import Callable, Optional
+
+
+def build_chat_payload(
+    message: str,
+    history: list,
+    *,
+    model: str,
+    thinking_mode: str,
+    user_context: Optional[dict],
+    project_context: str,
+    use_react_gateway: bool,
+) -> tuple[str, dict]:
+    """Build either the legacy chat payload or the shared ReAct envelope.
+
+    This is deliberately pure: it gives CLI, desktop, and iOS an auditable
+    parity point without forcing the local-first CLI to use cloud services.
+    """
+    if use_react_gateway:
+        context = dict(user_context or {})
+        if project_context:
+            context["project_context"] = project_context
+        mode = str(context.pop("workspace_mode", "code"))
+        return "/api/v2/chat/react", {
+            "message": {
+                "role": "user",
+                "content": [{"type": "text", "text": message}],
+            },
+            "mode": mode,
+            "surface": "aria_code",
+            "history": history[-20:],
+            "model": {"id": model or "auto", "effort": thinking_mode or "auto"},
+            "context": context,
+        }
+
+    payload: dict = {
+        "message": message,
+        "conversation_history": history[-20:],
+        "model": model,
+        "thinking_mode": thinking_mode,
+        "stream": True,
+    }
+    if user_context:
+        if project_context:
+            user_context = {**user_context, "project_context": project_context}
+        payload["user_context"] = user_context
+    return "/api/v2/ai/chat/stream", payload
+
+
+async def stream_chat(
+    base_url: str,
+    message: str,
+    history: list,
+    model: str = "qwen2.5:7b",
+    thinking_mode: str = "auto",
+    user_context: Optional[dict] = None,
+    auth_token: Optional[str] = None,
+    on_token: Optional[Callable[[str], None]] = None,
+    on_thinking: Optional[Callable[[str], None]] = None,
+    on_tool_call: Optional[Callable[[str, dict], None]] = None,
+    on_tool_result: Optional[Callable[[str, str], None]] = None,
+    on_status: Optional[Callable[[str, str], None]] = None,
+    cancel_event: Optional[asyncio.Event] = None,
+    project_context: str = "",
+    use_react_gateway: bool = False,
+) -> dict:
+    """Stream AI chat via SSE with cancel support and user context.
+
+    Parameters
+    ----------
+    project_context:
+        ARIA.md / CLAUDE.md content to inject into user_context.
+        Callers pass ``_PROJECT_CONTEXT`` from aria_cli, keeping this
+        module free of global state.
+    """
+    import aiohttp
+
+    endpoint, payload = build_chat_payload(
+        message, history, model=model, thinking_mode=thinking_mode,
+        user_context=user_context, project_context=project_context,
+        use_react_gateway=use_react_gateway,
+    )
+    url = f"{base_url.rstrip('/')}{endpoint}"
+
+    headers: dict = {}
+    if auth_token:
+        headers["Authorization"] = f"Bearer {auth_token}"
+
+    full_response = ""
+    thinking_content = ""
+    tools_used: list = []
+    sources: list = []
+    tool_calls_pending: list = []
+    usage: dict = {"prompt_tokens": 0, "completion_tokens": 0, "thinking_tokens": 0}
+
+    _max_connect_retries = 2
+    _last_connect_error: Optional[str] = None
+
+    for _attempt in range(_max_connect_retries + 1):
+        if cancel_event and cancel_event.is_set():
+            return {
+                "success": True, "response": "", "cancelled": True,
+                "tools_used": [], "sources": [], "usage": usage,
+            }
+        # Reset per-attempt accumulators
+        full_response = ""
+        thinking_content = ""
+        tools_used = []
+        sources = []
+        tool_calls_pending = []
+        usage = {"prompt_tokens": 0, "completion_tokens": 0, "thinking_tokens": 0}
+
+        try:
+            async with aiohttp.ClientSession() as session:
+                async with session.post(
+                    url, json=payload, headers=headers,
+                    timeout=aiohttp.ClientTimeout(total=120),
+                ) as resp:
+                    if resp.status != 200:
+                        error_text = await resp.text()
+                        return {"success": False, "error": f"HTTP {resp.status}: {error_text[:200]}"}
+
+                    buffer = ""
+                    event_type = "delta"
+
+                    async for chunk in resp.content:
+                        if cancel_event and cancel_event.is_set():
+                            try:
+                                if not use_react_gateway:
+                                    await session.post(
+                                        f"{base_url.rstrip('/')}/api/v2/ai/chat/cancel",
+                                        headers=headers,
+                                        timeout=aiohttp.ClientTimeout(total=3),
+                                    )
+                            except Exception:
+                                pass
+                            return {
+                                "success": True, "response": full_response,
+                                "cancelled": True, "tools_used": tools_used,
+                                "sources": sources, "usage": usage,
+                            }
+
+                        text = chunk.decode("utf-8", errors="ignore")
+                        buffer += text
+
+                        while "\n" in buffer:
+                            line, buffer = buffer.split("\n", 1)
+                            line = line.strip()
+
+                            if not line or line.startswith(":"):
+                                continue
+                            if line.startswith("event:"):
+                                event_type = line[6:].strip()
+                                continue
+                            if not line.startswith("data:"):
+                                continue
+
+                            data_str = line[5:].strip()
+                            if data_str == "[DONE]":
+                                break
+                            try:
+                                data = json.loads(data_str)
+                            except json.JSONDecodeError:
+                                continue
+
+                            # Backend error: {"success": false, "error": "..."}
+                            if data.get("success") is False:
+                                err_msg = data.get("error", "Backend error")
+                                return {"success": False, "error": f"Backend: {err_msg}"}
+
+                            evt = data.get("type", event_type)
+
+                            if evt == "delta":
+                                token = data.get("text", data.get("content", ""))
+                                if token:
+                                    full_response += token
+                                    usage["completion_tokens"] += 1
+                                    if on_token:
+                                        on_token(token)
+
+                            elif evt == "thinking_content":
+                                tc = data.get("content", "")
+                                if tc:
+                                    thinking_content += tc
+                                    usage["thinking_tokens"] += 1
+                                    if on_thinking:
+                                        on_thinking(tc)
+
+                            elif evt == "tool_call":
+                                tool = data.get("tool", data.get("name", ""))
+                                params = data.get("params", {})
+                                tools_used.append(tool)
+                                tool_calls_pending.append({"tool": tool, "params": params})
+                                if on_tool_call:
+                                    on_tool_call(tool, params)
+
+                            elif evt == "tool_result":
+                                if on_tool_result:
+                                    on_tool_result(data.get("tool", ""), data.get("summary", ""))
+
+                            elif evt == "status":
+                                if on_status:
+                                    on_status(data.get("state", ""), data.get("label", data.get("message", "")))
+
+                            elif evt == "final":
+                                full_response = data.get("answer", full_response)
+                                sources = data.get("sources", [])
+                                if data.get("usage"):
+                                    u = data["usage"]
+                                    usage["prompt_tokens"] = u.get("prompt_tokens", usage["prompt_tokens"])
+                                    usage["completion_tokens"] = u.get("completion_tokens", usage["completion_tokens"])
+
+                            elif evt == "error":
+                                return {"success": False, "error": data.get("message", data.get("error", "Unknown error"))}
+
+            return {
+                "success": True,
+                "response": full_response,
+                "thinking": thinking_content,
+                "tools_used": tools_used,
+                "sources": sources,
+                "tool_calls_pending": tool_calls_pending,
+                "usage": usage,
+            }
+
+        except asyncio.TimeoutError:
+            return {"success": False, "error": "Request timed out (120s)"}
+        except asyncio.CancelledError:
+            return {
+                "success": True, "response": full_response, "cancelled": True,
+                "tools_used": tools_used, "sources": sources, "usage": usage,
+            }
+        except aiohttp.ClientConnectorError as exc:
+            _last_connect_error = str(exc)
+            if _attempt < _max_connect_retries:
+                wait = 1.5 * (_attempt + 1)
+                await asyncio.sleep(wait)
+                if on_status:
+                    on_status("retry", f"Connection failed, retrying ({_attempt + 2}/{_max_connect_retries + 1})...")
+                continue
+            break
+        except Exception as exc:
+            return {"success": False, "error": str(exc)}
+
+    return {
+        "success": False,
+        "error": f"Connection failed after {_max_connect_retries + 1} attempts: {_last_connect_error}",
+    }

aria_code/apps/cli/providers/runtime_bridge.py

@@ -0,0 +1,353 @@
+"""Phase-3 bridge: run one chat turn through the shared ``runtime.run_agent``.
+
+The documented runtime next step is to route the CLI tool loop through
+``run_agent`` and keep aria_cli as orchestration glue. This module is that engine
+— the two adapters run_agent needs plus a thin driver:
+
+  • build_tool_executor() — wraps the CLI's ``LOCAL_TOOLS`` ({name: (handler, schema)})
+  • make_provider_fn()     — selects the provider (chat_routing) + streams it
+  • run_chat_via_runtime() — drives run_agent, renders via callbacks, returns text
+
+This is THE chat path: ``send_message`` runs every turn through it (the old
+inline per-round loop was retired in 2026-07 after the runtime path was
+validated with real turns). Tool approval and execution context are threaded
+through to run_agent's tool loop; on failure send_message attempts one direct
+cloud rescue (``providers/llm/registry.stream_cloud_fallback``) before
+presenting the error.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Callable, List, Optional
+
+from .chat_routing import first_round_route, is_placeholder_response, should_fallback
+
+
+def build_tool_executor(
+    local_tools,
+    config: Optional[dict] = None,
+    execution_context: Optional[Callable[[], dict]] = None,
+):
+    """Wrap the CLI's LOCAL_TOOLS registry for run_agent."""
+    from aria_code.runtime.tool_executor import ToolExecutor
+    return ToolExecutor(
+        local_tools,
+        config=config or {},
+        execution_context=execution_context,
+    )
+
+
+# Modes in which nothing can be written, so nothing can need verifying.
+_READ_ONLY_MODES = frozenset({"read-only", "readonly", "read_only", "plan"})
+
+
+def _declared_acceptance_commands(cfg: dict, message: str) -> tuple:
+    """What this workspace says "correct" means for this particular message.
+
+    Precedence, most specific first:
+
+      1. ``acceptance_commands`` in the session config — the user said it out
+         loud for this session, so nothing overrides it.
+      2. The active domain packs' commands. A pack contributes only when it
+         resolved a concrete entity from *this* message, so a declared
+         logistics check cannot fire on a payments question.
+      3. The workspace's ``acceptance.default`` from ``.ariarc``.
+
+    Nothing declared falls through to inference from the changed files, which
+    is the behaviour that existed before packs could speak here at all.
+    """
+    explicit = tuple(cfg.get("acceptance_commands") or ())
+    if explicit:
+        return explicit
+
+    commands: list = []
+    try:
+        from aria_code.packs import (
+            activate_packs,
+            active_acceptance_commands,
+            load_builtin_packs,
+        )
+
+        load_builtin_packs()
+        commands.extend(active_acceptance_commands(activate_packs(message or "")))
+    except Exception:
+        pass
+
+    try:
+        from aria_code.packs.rules import default_acceptance_commands
+
+        for command in default_acceptance_commands():
+            if command not in commands:
+                commands.append(command)
+    except Exception:
+        pass
+
+    return tuple(commands)
+
+
+def build_acceptance_gate(executor, config: Optional[dict] = None, message: str = ""):
+    """The CLI's acceptance gate, or ``None`` when this session shouldn't have one.
+
+    The gate runs its checks through the session's own ``run_command`` tool
+    rather than spawning subprocesses itself, so the workspace sandbox, the
+    command policy and the trace all apply to a verification run exactly as
+    they apply to a command the model asked for.
+
+    ``user_approved`` is set because the commands are the *planner's*, not the
+    model's or the user's prose — the same inferred plan ``/verify`` already
+    runs on request. Anything else would put an approval prompt between the
+    model finishing and the check that tells us whether it finished correctly,
+    which is the one place a prompt cannot help.
+    """
+    cfg = config or {}
+    if not cfg.get("acceptance_gate", True):
+        return None
+    mode = str(cfg.get("permission_mode", "workspace-write") or "")
+    if mode in _READ_ONLY_MODES:
+        return None
+    if "run_command" not in getattr(executor, "local_tools", {}):
+        return None
+
+    import os
+    from aria_code.runtime.acceptance import AcceptanceGate
+
+    timeout = int(cfg.get("acceptance_timeout", 300) or 300)
+
+    def _runner(command: str) -> dict:
+        return executor.execute_local("run_command", {
+            "command": command,
+            "policy": "balanced",
+            "permission_mode": mode,
+            "network_enabled": bool(cfg.get("network_enabled", True)),
+            "user_approved": True,
+            "timeout": timeout,
+        })
+
+    return AcceptanceGate(
+        runner=_runner,
+        root=os.getcwd(),
+        max_attempts=int(cfg.get("acceptance_max_attempts", 2) or 2),
+        commands=_declared_acceptance_commands(cfg, message),
+    )
+
+
+async def run_with_fallback(
+    route: str,
+    *,
+    run_cloud: Callable,
+    run_ollama: Callable,
+    on_token: Optional[Callable[[str], None]] = None,
+) -> dict:
+    """Primary generation per ``route``, with cloud→Ollama fallback parity.
+
+    Mirrors ``send_message``'s inline fallback, but keyed on *route* (via
+    ``should_fallback``) so a genuinely-good forced-backend answer is kept
+    instead of being discarded and re-run:
+
+      • ``skip`` / ``ollama`` → run local Ollama directly (no cloud round)
+      • ``cloud``            → run cloud; if it fails or returns a placeholder
+                               (empty / canned / backend stub), fall back to
+                               local Ollama
+
+    ``run_cloud`` / ``run_ollama`` are async ``(on_token) -> result dict``
+    closures; injecting them keeps this orchestration unit-testable without
+    real providers or network.
+    """
+    if route in ("skip", "ollama", "configured"):
+        return await run_ollama(on_token)
+
+    # route == "cloud": count streamed tokens so a long-but-unstreamed canned
+    # backend reply is recognised as a placeholder, not a real generation.
+    _tokens = [0]
+
+    def _counting_on_token(tok: str) -> None:
+        _tokens[0] += 1
+        if on_token is not None:
+            on_token(tok)
+
+    result = await run_cloud(_counting_on_token)
+    if result.get("cancelled"):
+        return result  # user-cancelled — never silently re-run on a different provider
+
+    placeholder = is_placeholder_response(result.get("response", ""), _tokens[0])
+    if should_fallback("cloud", result, is_placeholder=placeholder):
+        return await run_ollama(on_token)
+    return result
+
+
+def make_provider_fn(
+    *,
+    model: str,
+    config: dict,
+    api_url: Optional[str],
+    ollama_url: str,
+    tool_schemas: List[dict],
+    thinking_mode: str = "auto",
+    user_context: Optional[dict] = None,
+    auth_token: Optional[str] = None,
+    project_context: Any = None,
+    system_override: Optional[str] = None,
+) -> Callable:
+    """Build an async ``provider_fn`` for run_agent.
+
+    Selects the provider per chat_routing (cloud → AriaSSE backend; ollama/skip →
+    local Ollama) and streams it through the shared ``stream_provider_result``.
+    A pending system-role override is threaded the same way ``send_message`` does
+    it: cloud via ``user_context['system_role_override']``, Ollama via the
+    provider's ``system_override`` argument.
+    """
+    # Bare root on purpose: this is the module the tests patch, and the two
+    # roots are distinct module objects — importing the packaged one made
+    # monkeypatched providers silently unused.
+    from apps.cli.providers.base import AriaSSEProvider, ConfiguredProvider, OllamaProvider
+    # Bare root: the tests patch packages.aria_sdk.streaming, and the packaged
+    # root is a different module object, so the patch would not apply.
+    from packages.aria_sdk.streaming import stream_provider_result
+
+    _cloud_uctx = dict(user_context or {})
+    if system_override:
+        _cloud_uctx["system_role_override"] = system_override
+
+    def _scoped_tools(prompt: str) -> List[dict]:
+        """Tools this message may use: core always, domain only when claimed."""
+        try:
+            from aria_code.apps.cli.tool_scope import select_tool_schemas
+
+            return select_tool_schemas(tool_schemas, prompt)
+        except Exception:
+            return list(tool_schemas)
+
+    def _system_for(prompt: str) -> str:
+        """The rules this turn runs under, for the non-Ollama providers.
+
+        ollama_stream assembles its own (with prefetched data and sized
+        project context); everything else used to get nothing at all, so a
+        cloud model was never told the tool discipline. Built per message
+        because the right prompt depends on what was asked.
+        """
+        try:
+            from aria_code.apps.cli.prompts.select import build_turn_system_prompt
+
+            return build_turn_system_prompt(
+                prompt,
+                override=system_override,
+                project_context=str(project_context or ""),
+            )
+        except Exception:
+            return system_override or ""
+
+    async def _provider_fn(prompt, history, *, on_token=None, on_thinking=None,
+                           on_tool_call=None, on_tool_result=None, on_status=None,
+                           cancel_event=None):
+        route = first_round_route(model, config, api_url)
+
+        # ollama_stream does its own intent-based selection; the other
+        # providers had none, so a coding turn reached Gemini carrying all 74
+        # tool schemas including 34 domain tools. Scoped per message because
+        # what a turn may call depends on what it asked.
+        _scoped = _scoped_tools(prompt)
+
+        async def _stream(provider, _on_token):
+            return await stream_provider_result(
+                provider, prompt, history, tools=_scoped,
+                cancel_event=cancel_event, on_token=_on_token, on_thinking=on_thinking,
+                on_tool_call=on_tool_call, on_tool_result=on_tool_result, on_status=on_status,
+            )
+
+        async def run_cloud(_on_token):
+            return await _stream(
+                AriaSSEProvider(
+                    api_url, model, thinking_mode=thinking_mode,
+                    user_context=_cloud_uctx, auth_token=auth_token,
+                    project_context=project_context,
+                    use_react_gateway=bool(config.get("arthera_react_gateway")),
+                ),
+                _on_token,
+            )
+
+        async def run_ollama(_on_token):
+            selected = (
+                OllamaProvider(ollama_url, model, system_override=system_override)
+                if route == "ollama" else
+                ConfiguredProvider(config, model, system_override=_system_for(prompt))
+            )
+            return await _stream(
+                selected,
+                _on_token,
+            )
+
+        return await run_with_fallback(
+            route, run_cloud=run_cloud, run_ollama=run_ollama, on_token=on_token,
+        )
+
+    return _provider_fn
+
+
+async def run_chat_via_runtime(
+    *,
+    prompt: str,
+    history: list,
+    local_tools,
+    tool_schemas: List[dict],
+    model: str,
+    config: dict,
+    api_url: Optional[str],
+    ollama_url: str,
+    cancel_event=None,
+    on_token: Optional[Callable[[str], None]] = None,
+    on_thinking: Optional[Callable[[str], None]] = None,
+    on_tool_call: Optional[Callable[[str, dict], None]] = None,
+    on_tool_result: Optional[Callable[[str, dict], None]] = None,
+    on_status: Optional[Callable[[str, str], None]] = None,
+    thinking_mode: str = "auto",
+    user_context: Optional[dict] = None,
+    auth_token: Optional[str] = None,
+    project_context: Any = None,
+    system_override: Optional[str] = None,
+    max_rounds: int = 30,
+    return_result: bool = False,
+    execution_context: Optional[Callable[[], dict]] = None,
+    confirm_tools=(),
+    approval_callback: Optional[Callable] = None,
+    approval_applier: Optional[Callable] = None,
+    requires_evidence: bool = False,
+    grounding_tools=(),
+    evidence_already_grounded: bool = False,
+):
+    """Run one chat turn through the shared runtime Gateway.
+
+    This is the CLI *adapter* for ``runtime.gateway.run_turn``: it builds the
+    CLI's ``provider_fn`` (AriaSSE/Ollama selection + cloud→Ollama fallback) and
+    tool executor (the LOCAL_TOOLS registry), then hands them to the neutral
+    gateway, which drives ``run_agent`` and streams via the callbacks. By
+    default this returns assistant text for compatibility. ``return_result``
+    exposes the gateway result so terminal adapters can preserve provider and
+    usage metadata during final rendering.
+    """
+    from aria_code.runtime.gateway import run_turn
+
+    provider_fn = make_provider_fn(
+        model=model, config=config, api_url=api_url, ollama_url=ollama_url,
+        tool_schemas=tool_schemas, thinking_mode=thinking_mode,
+        user_context=user_context, auth_token=auth_token, project_context=project_context,
+        system_override=system_override,
+    )
+    executor = build_tool_executor(local_tools, config, execution_context)
+    gate = build_acceptance_gate(executor, config, prompt)
+
+    result = await run_turn(
+        prompt, history,
+        provider_fn=provider_fn, tool_executor=executor,
+        tool_schemas=list(tool_schemas),
+        on_token=on_token, on_thinking=on_thinking,
+        on_tool_call=on_tool_call, on_tool_result=on_tool_result, on_status=on_status,
+        cancel_event=cancel_event, max_rounds=max_rounds,
+        confirm_tools=confirm_tools,
+        approval_callback=approval_callback,
+        approval_applier=approval_applier,
+        requires_evidence=requires_evidence,
+        grounding_tools=grounding_tools,
+        evidence_already_grounded=evidence_already_grounded,
+        acceptance=gate,
+    )
+    return result if return_result else result.text