aria-code 4.1.3__py3-none-any.whl

packages/aria_sdk/streaming.py

@@ -0,0 +1,73 @@
+"""Provider streaming helpers shared by SDK and CLI adapters."""
+
+from __future__ import annotations
+
+import asyncio
+from typing import Callable
+
+from apps.cli.providers.base import (
+    LLMDone,
+    LLMProvider,
+    LLMStatus,
+    LLMThinking,
+    LLMToken,
+    LLMToolCall,
+    LLMToolResult,
+)
+
+
+async def stream_provider_result(
+    provider: LLMProvider,
+    prompt: str,
+    history: list,
+    *,
+    tools: list | tuple | None = None,
+    cancel_event: asyncio.Event | None = None,
+    on_token: Callable[[str], None] | None = None,
+    on_thinking: Callable[[str], None] | None = None,
+    on_tool_call: Callable[[str, dict], None] | None = None,
+    on_tool_result: Callable[[str, str], None] | None = None,
+    on_status: Callable[[str, str], None] | None = None,
+) -> dict:
+    """Stream one provider turn and return the standard Aria result dict."""
+
+    messages = list(history or []) + [{"role": "user", "content": prompt}]
+    response_parts: list[str] = []
+    tool_calls: list[dict] = []
+    final = LLMDone(response="", provider="unknown", success=True)
+
+    async for event in provider.stream(messages, list(tools or []), cancel_event=cancel_event):
+        if isinstance(event, LLMToken):
+            response_parts.append(event.text)
+            if on_token:
+                on_token(event.text)
+        elif isinstance(event, LLMThinking):
+            if on_thinking:
+                on_thinking(event.content)
+        elif isinstance(event, LLMToolCall):
+            call = {"tool": event.tool, "params": dict(event.params)}
+            tool_calls.append(call)
+            if on_tool_call:
+                on_tool_call(event.tool, dict(event.params))
+        elif isinstance(event, LLMToolResult):
+            if on_tool_result:
+                on_tool_result(event.tool, event.summary)
+        elif isinstance(event, LLMStatus):
+            if on_status:
+                on_status(event.state, event.message)
+        elif isinstance(event, LLMDone):
+            final = event
+
+    response = final.response or "".join(response_parts)
+    return {
+        "success": final.success,
+        "response": response,
+        "provider": final.provider,
+        "tool_calls_pending": tool_calls or list(final.tool_calls_pending),
+        "usage": dict(final.usage),
+        "cancelled": final.cancelled,
+        "error": final.error,
+    }
+
+
+__all__ = ["stream_provider_result"]

packages/aria_sdk/types.py

@@ -0,0 +1,86 @@
+"""Typed public objects for the lightweight Aria Agent SDK."""
+
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass, field
+from typing import Any, Callable
+
+
+@dataclass(frozen=True)
+class AriaAgentOptions:
+    """Options for an Aria SDK agent session.
+
+    The fields mirror the concerns exposed by modern agent SDKs: model/provider
+    selection, deterministic tool routing, permission intent, cwd, and metadata.
+    CLI rendering and terminal state stay outside this contract.
+    """
+
+    model: str = "qwen2.5-coder:1.5b"
+    provider: str = "auto"
+    ollama_url: str = "http://localhost:11434"
+    api_url: str = "http://localhost:8000"
+    auth_token: str = ""
+    thinking_mode: str = "auto"
+    user_context: dict[str, Any] = field(default_factory=dict)
+    local_mode: bool = True
+    deterministic: bool = True
+    model_has_tools: bool = False
+    system_prompt: str = ""
+    permission_mode: str = "workspace-write"
+    allowed_tools: tuple[str, ...] = ()
+    disallowed_tools: tuple[str, ...] = ()
+    tool_schemas: tuple[dict[str, Any], ...] = ()
+    max_turns: int = 1
+    cwd: str = ""
+    metadata: dict[str, Any] = field(default_factory=dict)
+    has_brokers: bool = False
+    get_broker_registry: Callable[[], Any] | None = field(
+        default=None,
+        repr=False,
+        compare=False,
+    )
+
+    def to_dict(self) -> dict[str, Any]:
+        data = asdict(self)
+        data["get_broker_registry"] = None
+        return data
+
+
+@dataclass(frozen=True)
+class AriaMessage:
+    """Event/message yielded by the SDK query stream."""
+
+    kind: str
+    content: str = ""
+    role: str = ""
+    data: dict[str, Any] = field(default_factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "kind": self.kind,
+            "role": self.role,
+            "content": self.content,
+            "data": dict(self.data),
+        }
+
+
+@dataclass(frozen=True)
+class AriaResult:
+    """Final collected SDK result."""
+
+    success: bool
+    content: str = ""
+    provider: str = ""
+    session_id: str = ""
+    error: str = ""
+    data: dict[str, Any] = field(default_factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        return asdict(self)
+
+
+__all__ = [
+    "AriaAgentOptions",
+    "AriaMessage",
+    "AriaResult",
+]

packages/aria_services/__init__.py

@@ -0,0 +1,55 @@
+"""Service boundary manifests for Aria Code."""
+
+from .context import (
+    ContextDecision,
+    ContextPolicy,
+    ContextService,
+    ContextSummaryEnvelope,
+    build_context_service,
+)
+from .provider_health import (
+    GLOBAL_PROVIDER_HEALTH,
+    ProviderHealthRegistry,
+    ProviderIssue,
+    ProviderState,
+    classify_provider_error,
+    summarize_provider_health,
+)
+from .registry import ServiceSpec, list_service_specs, required_service_names, service_map
+from .usage import ServiceUsageSpec, list_service_usage_specs, service_usage_map
+
+__all__ = [
+    "ContextDecision",
+    "ContextPolicy",
+    "ContextService",
+    "ContextSummaryEnvelope",
+    "DataBundle",
+    "DataService",
+    "DataServiceResult",
+    "GLOBAL_PROVIDER_HEALTH",
+    "ProviderHealthRegistry",
+    "ProviderIssue",
+    "ProviderState",
+    "ServiceSpec",
+    "ServiceUsageSpec",
+    "build_context_service",
+    "classify_provider_error",
+    "list_service_specs",
+    "list_service_usage_specs",
+    "required_service_names",
+    "service_map",
+    "service_usage_map",
+    "summarize_provider_health",
+]
+
+
+def __getattr__(name: str):
+    if name in {"DataBundle", "DataService", "DataServiceResult"}:
+        from .data import DataBundle, DataService, DataServiceResult
+
+        return {
+            "DataBundle": DataBundle,
+            "DataService": DataService,
+            "DataServiceResult": DataServiceResult,
+        }[name]
+    raise AttributeError(name)

packages/aria_services/context.py

@@ -0,0 +1,258 @@
+"""Context management service for Aria Code.
+
+This module owns deterministic context pressure and local compaction behavior.
+LLM-based summarisation remains an adapter concern, but the prompt/envelope
+shape is defined here so CLI, daemon, and future channels can share it.
+"""
+
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass
+from typing import Any, Dict, Iterable, List
+
+
+def _int_or(value: Any, default: int) -> int:
+    try:
+        return int(value)
+    except Exception:
+        return default
+
+
+def _float_or(value: Any, default: float) -> float:
+    try:
+        return float(value)
+    except Exception:
+        return default
+
+
+@dataclass(frozen=True)
+class ContextPolicy:
+    max_tokens: int = 16384
+    threshold: float = 0.78
+    min_messages: int = 8
+    target_ratio: float = 0.55
+    compact_ratio: float = 0.70
+    tail_messages: int = 8
+    summary_tail_messages: int = 6
+
+    def normalized(self) -> "ContextPolicy":
+        max_tokens = max(1024, _int_or(self.max_tokens, 16384))
+        threshold = max(0.50, min(0.95, _float_or(self.threshold, 0.78)))
+        min_messages = max(1, _int_or(self.min_messages, 8))
+        target_ratio = max(0.20, min(0.85, _float_or(self.target_ratio, 0.55)))
+        compact_ratio = max(target_ratio, min(0.90, _float_or(self.compact_ratio, 0.70)))
+        tail_messages = max(2, _int_or(self.tail_messages, 8))
+        summary_tail_messages = max(2, _int_or(self.summary_tail_messages, 6))
+        return ContextPolicy(
+            max_tokens=max_tokens,
+            threshold=threshold,
+            min_messages=min_messages,
+            target_ratio=target_ratio,
+            compact_ratio=compact_ratio,
+            tail_messages=tail_messages,
+            summary_tail_messages=summary_tail_messages,
+        )
+
+
+@dataclass(frozen=True)
+class ContextDecision:
+    should_compact: bool
+    estimated_tokens: int
+    max_tokens: int
+    fill_ratio: float
+    fill_pct: int
+    threshold: float
+    message_count: int
+    reason: str = ""
+    target_tokens: int = 0
+
+    def to_dict(self) -> Dict[str, Any]:
+        return asdict(self)
+
+
+@dataclass(frozen=True)
+class ContextSummaryEnvelope:
+    messages: List[Dict[str, str]]
+    old_message_count: int
+    new_message_count: int
+    tail_message_count: int
+
+    def to_dict(self) -> Dict[str, Any]:
+        return asdict(self)
+
+
+class ContextService:
+    """Pure context service with no terminal, Rich, or LLM dependency."""
+
+    def __init__(self, policy: ContextPolicy | None = None):
+        self.policy = (policy or ContextPolicy()).normalized()
+
+    @staticmethod
+    def estimate_message_tokens(messages: Iterable[dict], extra_content: str = "") -> int:
+        total_chars = sum(len(str(message.get("content", ""))) for message in messages)
+        total_chars += len(str(extra_content or ""))
+        return total_chars // 3
+
+    def compaction_decision(self, messages: List[dict], extra_content: str = "") -> ContextDecision:
+        estimated = self.estimate_message_tokens(messages, extra_content=extra_content)
+        max_tokens = max(self.policy.max_tokens, 1)
+        fill_ratio = estimated / max_tokens
+        message_count = len(messages)
+        reason = ""
+        should_compact = False
+        if message_count < self.policy.min_messages:
+            reason = "message_count_below_minimum"
+        elif fill_ratio >= self.policy.threshold:
+            reason = "threshold_exceeded"
+            should_compact = True
+        else:
+            reason = "below_threshold"
+        return ContextDecision(
+            should_compact=should_compact,
+            estimated_tokens=estimated,
+            max_tokens=max_tokens,
+            fill_ratio=fill_ratio,
+            fill_pct=min(100, int(fill_ratio * 100)),
+            threshold=self.policy.threshold,
+            message_count=message_count,
+            reason=reason,
+            target_tokens=int(max_tokens * self.policy.target_ratio),
+        )
+
+    def compact_messages(self, messages: List[dict], max_chars: int = 0) -> List[dict]:
+        """Compact history locally while preserving recent turns and errors."""
+
+        if max_chars <= 0:
+            max_chars = int(self.policy.max_tokens * 3 * self.policy.compact_ratio)
+
+        total = sum(len(str(message.get("content", ""))) for message in messages)
+        if total <= max_chars or len(messages) <= self.policy.tail_messages:
+            return messages
+
+        system = messages[0]
+        keep_tail = min(self.policy.tail_messages, max(2, len(messages) - 1))
+        middle = messages[1:-keep_tail]
+        tail = messages[-keep_tail:]
+
+        compacted: List[dict] = [system]
+        for message in middle:
+            compacted.append(self._compact_middle_message(message))
+        compacted.extend(tail)
+        return compacted
+
+    def _compact_middle_message(self, message: dict) -> dict:
+        content = str(message.get("content", ""))
+        role = str(message.get("role", ""))
+
+        if role == "tool" and len(content) > 200:
+            lines = content.splitlines()
+            kept: List[str] = []
+            has_error = False
+            for line in lines[:30]:
+                stripped = line.strip()
+                if not stripped:
+                    continue
+                low = stripped.lower()
+                if any(keyword in low for keyword in ("error", "traceback", "exception", "failed", "failure")):
+                    kept.append(stripped)
+                    has_error = True
+                elif len(kept) < 4 and len(stripped) > 8:
+                    kept.append(stripped)
+            summary = " | ".join(kept[:4]) if kept else content[:150]
+            flag = " [error preserved]" if has_error else " [compacted]"
+            return {"role": role, "content": f"{summary}{flag}"}
+
+        if role == "assistant" and len(content) > 500:
+            paras = [part.strip() for part in content.split("\n\n") if part.strip()]
+            if len(paras) >= 2:
+                head = paras[0][:280]
+                tail = paras[-1][-180:]
+                return {"role": role, "content": f"{head}\n...\n{tail} [compacted]"}
+            return {"role": role, "content": content[:350] + "... [compacted]"}
+
+        return message
+
+    def build_summary_transcript(self, messages: List[dict]) -> str:
+        parts: List[str] = []
+        for message in messages:
+            role = str(message.get("role", ""))
+            content = str(message.get("content", ""))
+            if role == "tool":
+                lines = [line.strip() for line in content.splitlines() if line.strip()]
+                has_error = any(
+                    "error" in line.lower() or "traceback" in line.lower()
+                    for line in lines[:10]
+                )
+                excerpt = " | ".join(lines[:3]) if lines else content[:200]
+                label = "Tool[error]" if has_error else "Tool"
+                parts.append(f"{label}: {excerpt[:300]}")
+            elif role == "user":
+                parts.append(f"User: {content[:800]}")
+            else:
+                parts.append(f"Aria: {content[:1200]}")
+        return "\n\n".join(parts)
+
+    def build_summary_prompt(self, messages: List[dict]) -> str:
+        transcript = self.build_summary_transcript(messages)
+        return (
+            "You are a context compressor for a quantitative finance AI assistant.\n"
+            "Given the conversation transcript, produce a DENSE SUMMARY (<=350 words).\n"
+            "You MUST preserve:\n"
+            "  - All ticker symbols / asset names discussed\n"
+            "  - Key numerical results (prices, rates, backtest metrics)\n"
+            "  - Code files written or modified (file paths + purpose)\n"
+            "  - Errors encountered and how they were resolved\n"
+            "  - User preferences or decisions made\n"
+            "  - The last task status (complete / in-progress / blocked)\n"
+            "Write in concise third-person present tense. "
+            "Start with: 'Session summary: ...'\n\n"
+            f"TRANSCRIPT:\n{transcript}\n\nSUMMARY:"
+        )
+
+    def build_summary_envelope(self, messages: List[dict], summary: str) -> ContextSummaryEnvelope:
+        tail_count = min(self.policy.summary_tail_messages, len(messages))
+        tail = messages[-tail_count:] if tail_count else []
+        envelope_messages = [
+            {
+                "role": "user",
+                "content": (
+                    "[Session summary - earlier conversation compressed]\n\n"
+                    f"{summary.strip()}\n\n"
+                    "[Recent conversation follows]"
+                ),
+            },
+            {
+                "role": "assistant",
+                "content": "Summary loaded. Continuing with the current task.",
+            },
+            *tail,
+        ]
+        return ContextSummaryEnvelope(
+            messages=envelope_messages,
+            old_message_count=len(messages),
+            new_message_count=len(envelope_messages),
+            tail_message_count=tail_count,
+        )
+
+
+def build_context_service(
+    *,
+    max_tokens: int = 16384,
+    threshold: float = 0.78,
+    min_messages: int = 8,
+    target_ratio: float = 0.55,
+    compact_ratio: float = 0.70,
+    tail_messages: int = 8,
+    summary_tail_messages: int = 6,
+) -> ContextService:
+    return ContextService(
+        ContextPolicy(
+            max_tokens=max_tokens,
+            threshold=threshold,
+            min_messages=min_messages,
+            target_ratio=target_ratio,
+            compact_ratio=compact_ratio,
+            tail_messages=tail_messages,
+            summary_tail_messages=summary_tail_messages,
+        )
+    )

packages/aria_services/data.py

@@ -0,0 +1,11 @@
+"""Data service facade for package-level imports."""
+
+from __future__ import annotations
+
+from data_service import DataBundle, DataService, DataServiceResult
+
+__all__ = [
+    "DataBundle",
+    "DataService",
+    "DataServiceResult",
+]

packages/aria_services/provider_health.py

@@ -0,0 +1,189 @@
+"""Provider error classification and lightweight health state."""
+
+from __future__ import annotations
+
+import time
+from dataclasses import asdict, dataclass
+from typing import Any, Dict, List
+
+
+@dataclass(frozen=True)
+class ProviderIssue:
+    provider: str
+    category: str
+    message: str
+    retryable: bool = True
+    cooldown_seconds: int = 0
+
+    def to_dict(self) -> Dict[str, Any]:
+        return asdict(self)
+
+
+@dataclass
+class ProviderState:
+    provider: str
+    status: str = "ok"
+    last_error_category: str = ""
+    last_error: str = ""
+    failures: int = 0
+    cooldown_until: float = 0.0
+    last_seen_at: float = 0.0
+    last_success_at: float = 0.0
+
+    def to_dict(self) -> Dict[str, Any]:
+        data = asdict(self)
+        data["cooldown_active"] = self.cooldown_until > time.time()
+        data["cooldown_remaining_seconds"] = max(0, int(self.cooldown_until - time.time()))
+        return data
+
+
+@dataclass(frozen=True)
+class ProviderHealthSummary:
+    schema: str
+    total: int
+    ok: int
+    warn: int
+    err: int
+    cooldown: int
+    auth_errors: int
+    providers: List[str]
+    status: str
+    detail: str
+    suggestion: str
+
+    def to_dict(self) -> Dict[str, Any]:
+        return asdict(self)
+
+
+def classify_provider_error(provider: str, error: Any) -> ProviderIssue:
+    text = str(error or "").strip()
+    low = text.lower()
+    if not text:
+        return ProviderIssue(provider, "unavailable", "provider returned no usable data", True, 30)
+    if any(token in low for token in ("429", "rate", "too many", "limit")):
+        return ProviderIssue(provider, "rate_limited", "provider rate limited the request", True, 60)
+    if any(token in low for token in ("timeout", "timed out", "curl: (28)", "read timed out")):
+        return ProviderIssue(provider, "timeout", "provider request timed out", True, 30)
+    if any(token in low for token in ("connection", "network", "refused", "remote", "dns", "name resolution")):
+        return ProviderIssue(provider, "network", "provider network connection failed", True, 30)
+    if any(token in low for token in ("empty", "no data", "not found", "none", "null")):
+        return ProviderIssue(provider, "no_data", "provider returned no market data", True, 15)
+    if any(token in low for token in ("unauthorized", "forbidden", "api key", "401", "403")):
+        return ProviderIssue(provider, "auth", "provider authentication failed", False, 0)
+    return ProviderIssue(provider, "error", text[:240], True, 30)
+
+
+class ProviderHealthRegistry:
+    """In-process health state for data providers."""
+
+    def __init__(self) -> None:
+        self._states: Dict[str, ProviderState] = {}
+
+    def mark_success(self, provider: str) -> None:
+        if not provider:
+            return
+        state = self._states.setdefault(provider, ProviderState(provider=provider))
+        state.status = "ok"
+        state.last_error_category = ""
+        state.last_error = ""
+        state.failures = 0
+        state.cooldown_until = 0.0
+        now = time.time()
+        state.last_seen_at = now
+        state.last_success_at = now
+
+    def mark_issue(self, issue: ProviderIssue) -> None:
+        if not issue.provider:
+            return
+        state = self._states.setdefault(issue.provider, ProviderState(provider=issue.provider))
+        now = time.time()
+        state.status = issue.category
+        state.last_error_category = issue.category
+        state.last_error = issue.message
+        state.failures += 1
+        state.last_seen_at = now
+        if issue.cooldown_seconds:
+            state.cooldown_until = max(state.cooldown_until, now + issue.cooldown_seconds)
+
+    def provider_in_cooldown(self, provider: str) -> bool:
+        state = self._states.get(provider)
+        return bool(state and state.cooldown_until > time.time())
+
+    def snapshot(self) -> List[Dict[str, Any]]:
+        return [self._states[name].to_dict() for name in sorted(self._states)]
+
+    def summary(self) -> ProviderHealthSummary:
+        return summarize_provider_health(self.snapshot())
+
+
+GLOBAL_PROVIDER_HEALTH = ProviderHealthRegistry()
+
+
+def summarize_provider_health(snapshot: List[Dict[str, Any]] | None = None) -> ProviderHealthSummary:
+    rows = list(snapshot or [])
+    if not rows:
+        return ProviderHealthSummary(
+            schema="aria.provider_health_summary.v1",
+            total=0,
+            ok=0,
+            warn=0,
+            err=0,
+            cooldown=0,
+            auth_errors=0,
+            providers=[],
+            status="warn",
+            detail="no provider calls recorded in this session",
+            suggestion="Run /quote, /ta, /analyze, or /report to populate provider health.",
+        )
+
+    ok = warn = err = cooldown = auth_errors = 0
+    providers: list[str] = []
+    for row in rows:
+        provider = str(row.get("provider") or "provider")
+        providers.append(provider)
+        status = str(row.get("status") or "unknown")
+        error_category = str(row.get("last_error_category") or "")
+        if status == "ok":
+            ok += 1
+        elif error_category == "auth":
+            err += 1
+            auth_errors += 1
+        else:
+            warn += 1
+        if row.get("cooldown_active"):
+            cooldown += 1
+
+    if err:
+        status = "err"
+    elif warn or cooldown:
+        status = "warn"
+    else:
+        status = "ok"
+
+    parts = [f"{len(rows)} providers"]
+    if ok:
+        parts.append(f"{ok} ok")
+    if warn:
+        parts.append(f"{warn} warn")
+    if err:
+        parts.append(f"{err} err")
+    if cooldown:
+        parts.append(f"{cooldown} cooldown")
+
+    suggestion = "Run /doctor --network or inspect /apikey." if status != "ok" else "All providers healthy."
+    if auth_errors:
+        suggestion = "Fix API keys first, then retry /doctor or /cloud health."
+
+    return ProviderHealthSummary(
+        schema="aria.provider_health_summary.v1",
+        total=len(rows),
+        ok=ok,
+        warn=warn,
+        err=err,
+        cooldown=cooldown,
+        auth_errors=auth_errors,
+        providers=providers,
+        status=status,
+        detail=", ".join(parts),
+        suggestion=suggestion,
+    )