aria-code 4.1.3__py3-none-any.whl

packages/aria_mcp/config.py

@@ -0,0 +1,97 @@
+"""MCP configuration helpers for Aria and Arthera package bridges."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+
+def arthera_quant_engine_server_config(
+    arthera_root: Optional[Path] = None,
+) -> Dict[str, object]:
+    """Return a ready-to-write MCP server entry for Arthera QuantEngine."""
+
+    root = (arthera_root or Path.home() / "Desktop" / "Arthera").expanduser()
+    server = root / "packages" / "quant_engine" / "mcp_server.py"
+    return {
+        "name": "arthera_quant_engine",
+        "command": "python3",
+        "args": [str(server)],
+        "env": {"PYTHONPATH": str(root)},
+        "description": "Arthera QuantEngine tools exposed through MCP",
+    }
+
+
+def merge_server_config(existing: Dict[str, object], server: Dict[str, object]) -> Dict[str, object]:
+    """Return config with server upserted by name."""
+
+    servers = list(existing.get("servers") or [])
+    name = server.get("name")
+    out = []
+    replaced = False
+    for item in servers:
+        if isinstance(item, dict) and item.get("name") == name:
+            out.append(server)
+            replaced = True
+        else:
+            out.append(item)
+    if not replaced:
+        out.append(server)
+    return {**existing, "servers": out}
+
+
+def load_mcp_config(path: Path) -> Dict[str, object]:
+    if not path.exists():
+        return {"servers": []}
+    try:
+        return json.loads(path.read_text(encoding="utf-8"))
+    except Exception:
+        return {"servers": []}
+
+
+def write_mcp_config(path: Path, config: Dict[str, object]) -> Path:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(config, ensure_ascii=False, indent=2), encoding="utf-8")
+    return path
+
+
+def find_server_config(config: Dict[str, object], name: str) -> Optional[Dict[str, object]]:
+    for item in config.get("servers") or []:
+        if isinstance(item, dict) and item.get("name") == name:
+            return item
+    return None
+
+
+def mcp_server_status(
+    config_path: Path,
+    server_name: str = "arthera_quant_engine",
+    runtime_status: Optional[List[Dict[str, Any]]] = None,
+) -> Dict[str, Any]:
+    """Return config/file/runtime status for a configured MCP server."""
+
+    config = load_mcp_config(config_path)
+    server = find_server_config(config, server_name)
+    runtime = None
+    for item in runtime_status or []:
+        if item.get("name") == server_name:
+            runtime = item
+            break
+
+    server_path = None
+    if server:
+        args = server.get("args") or []
+        if args:
+            server_path = Path(str(args[0])).expanduser()
+
+    return {
+        "name": server_name,
+        "config_path": str(config_path),
+        "configured": server is not None,
+        "server_path": str(server_path) if server_path else "",
+        "server_file_exists": bool(server_path and server_path.exists()),
+        "running": bool(runtime and runtime.get("running")),
+        "tool_count": int(runtime.get("tool_count", 0)) if runtime else 0,
+        "tools": list(runtime.get("tools", [])) if runtime else [],
+        "description": (server or {}).get("description", ""),
+    }

packages/aria_mcp/tools.py

@@ -0,0 +1,61 @@
+"""Adapters from MCP tool descriptors to Aria tool manifests."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, Iterable, List
+
+from packages.aria_core import PermissionLevel
+from packages.aria_tools import ToolSpec
+
+
+def _capabilities_for_mcp_tool(name: str, description: str = "") -> List[str]:
+    text = f"{name} {description}".lower()
+    capabilities: List[str] = []
+    if any(word in text for word in ("quote", "market", "ohlc", "price")):
+        capabilities.append("market.data")
+    if any(word in text for word in ("backtest", "strategy", "simulation")):
+        capabilities.append("strategy.backtest")
+    if any(word in text for word in ("risk", "var", "cvar", "drawdown")):
+        capabilities.append("risk")
+    if any(word in text for word in ("factor", "alpha", "feature")):
+        capabilities.append("factors")
+    if any(word in text for word in ("signal", "predict", "regime")):
+        capabilities.append("signals")
+    if any(word in text for word in ("news", "filing", "web", "search")):
+        capabilities.append("research")
+    if any(word in text for word in ("trade", "order", "execution")):
+        capabilities.append("broker")
+    return capabilities or ["mcp.tool"]
+
+
+def _permissions_for_mcp_tool(name: str, description: str = "") -> List[PermissionLevel]:
+    text = f"{name} {description}".lower()
+    if any(word in text for word in ("trade", "order", "execution")):
+        return [PermissionLevel.NETWORK, PermissionLevel.BROKER_TRADE]
+    if any(word in text for word in ("write", "export", "report", "backtest")):
+        return [PermissionLevel.NETWORK, PermissionLevel.WORKSPACE_WRITE]
+    return [PermissionLevel.NETWORK]
+
+
+def mcp_tool_to_spec(tool: Dict[str, Any], server_name: str) -> ToolSpec:
+    """Convert one MCP tool descriptor into an Aria ToolSpec."""
+
+    short_name = str(tool.get("name") or "unknown")
+    qualified_name = str(tool.get("qualified_name") or f"{server_name}/{short_name}")
+    description = str(tool.get("description") or f"MCP tool from {server_name}")
+    schema = tool.get("inputSchema") or tool.get("parameters") or {}
+    return ToolSpec(
+        name=qualified_name,
+        handler=None,
+        description=description,
+        schema=schema if isinstance(schema, dict) else {},
+        permissions=_permissions_for_mcp_tool(short_name, description),
+        capabilities=_capabilities_for_mcp_tool(short_name, description),
+    )
+
+
+def mcp_tools_to_specs(tools: Iterable[Dict[str, Any]], server_name: str) -> List[ToolSpec]:
+    return sorted(
+        [mcp_tool_to_spec(tool, server_name) for tool in tools],
+        key=lambda item: item.name,
+    )

packages/aria_sdk/__init__.py

@@ -0,0 +1,19 @@
+"""Public Aria Agent SDK facade."""
+
+from .client import AriaSDKClient, query, run
+from .providers import ProviderSelection, build_llm_provider, normalize_provider_name
+from .streaming import stream_provider_result
+from .types import AriaAgentOptions, AriaMessage, AriaResult
+
+__all__ = [
+    "AriaAgentOptions",
+    "AriaMessage",
+    "AriaResult",
+    "AriaSDKClient",
+    "ProviderSelection",
+    "build_llm_provider",
+    "normalize_provider_name",
+    "query",
+    "run",
+    "stream_provider_result",
+]

packages/aria_sdk/client.py

@@ -0,0 +1,396 @@
+"""Embeddable Aria Agent SDK client.
+
+The SDK owns the agent-facing event stream.  Terminal UI, Rich panels, and
+interactive prompts remain CLI adapters layered above this package.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import os
+import uuid
+from dataclasses import replace
+from typing import AsyncGenerator
+
+from apps.cli.deterministic import run_deterministic_chain
+from apps.cli.providers.base import (
+    LLMDone,
+    LLMStatus,
+    LLMThinking,
+    LLMToken,
+    LLMToolCall,
+    LLMToolResult,
+)
+from runtime import (
+    AgentEventCancelled,
+    AgentEventComplete,
+    AgentEventError,
+    AgentEventStatus,
+    AgentEventThinking,
+    AgentEventToken,
+    AgentEventToolCall,
+    AgentEventToolResult,
+    AgentOptions,
+    ToolExecutor,
+    run_agent,
+)
+
+from .providers import build_llm_provider
+from .streaming import stream_provider_result
+from .types import AriaAgentOptions, AriaMessage, AriaResult
+
+
+class AriaSDKClient:
+    """A reusable agent client that can be embedded outside the terminal CLI."""
+
+    def __init__(
+        self,
+        options: AriaAgentOptions | None = None,
+        *,
+        session_id: str | None = None,
+        tool_executor: ToolExecutor | None = None,
+        remote_runner=None,
+        tool_result_formatter=None,
+    ) -> None:
+        self.options = options or AriaAgentOptions()
+        self.session_id = session_id or uuid.uuid4().hex
+        self.messages: list[dict[str, str]] = []
+        self.tool_executor = tool_executor
+        self.remote_runner = remote_runner
+        self.tool_result_formatter = tool_result_formatter
+
+    async def query(
+        self,
+        prompt: str,
+        *,
+        history: list | None = None,
+        cancel_event: asyncio.Event | None = None,
+    ) -> AsyncGenerator[AriaMessage, None]:
+        """Yield SDK events for one agent turn."""
+
+        active_history = list(history) if history is not None else list(self.messages)
+        user_record = {"role": "user", "content": prompt}
+
+        yield AriaMessage(
+            kind="system",
+            role="system",
+            content="aria_sdk.turn_started",
+            data={
+                "session_id": self.session_id,
+                "model": self.options.model,
+                "provider": self.options.provider,
+                "local_mode": self.options.local_mode,
+                "cwd": self.options.cwd or os.getcwd(),
+                "permission_mode": self.options.permission_mode,
+            },
+        )
+        yield AriaMessage(kind="user", role="user", content=prompt)
+
+        if self.options.deterministic:
+            deterministic = run_deterministic_chain(
+                prompt,
+                model_has_tools=self.options.model_has_tools,
+                history=active_history,
+                has_brokers=self.options.has_brokers,
+                get_broker_registry=self.options.get_broker_registry,
+            )
+            if deterministic.get("success"):
+                content = str(deterministic.get("response", ""))
+                self.messages.extend([user_record, {"role": "assistant", "content": content}])
+                yield AriaMessage(
+                    kind="assistant",
+                    role="assistant",
+                    content=content,
+                    data={
+                        "provider": "deterministic",
+                        "tools_used": list(deterministic.get("tools_used") or []),
+                        "raw": deterministic,
+                    },
+                )
+                yield AriaMessage(
+                    kind="result",
+                    role="assistant",
+                    content=content,
+                    data={
+                        "success": True,
+                        "provider": "deterministic",
+                        "session_id": self.session_id,
+                        "tools_used": list(deterministic.get("tools_used") or []),
+                    },
+                )
+                return
+
+        if self.tool_executor is not None:
+            async for event in self._run_agent(prompt, history=active_history, cancel_event=cancel_event):
+                yield event
+            return
+
+        async for event in self._run_llm(prompt, history=active_history, cancel_event=cancel_event):
+            yield event
+
+    async def _provider_result(
+        self,
+        prompt: str,
+        history: list,
+        *,
+        on_token=None,
+        on_thinking=None,
+        on_tool_call=None,
+        on_tool_result=None,
+        on_status=None,
+        cancel_event: asyncio.Event | None = None,
+    ) -> dict:
+        selection = build_llm_provider(self.options)
+        result = await stream_provider_result(
+            selection.provider,
+            prompt,
+            history,
+            tools=list(self.options.tool_schemas),
+            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,
+        )
+        if not result.get("provider") or result.get("provider") == "unknown":
+            result["provider"] = selection.name
+        return result
+
+    async def _run_agent(
+        self,
+        prompt: str,
+        *,
+        history: list,
+        cancel_event: asyncio.Event | None = None,
+    ) -> AsyncGenerator[AriaMessage, None]:
+        """Run the provider through the shared runtime tool loop."""
+
+        if self.tool_executor is None:
+            return
+
+        final_text = ""
+        async for event in run_agent(
+            prompt,
+            history,
+            provider_fn=self._provider_result,
+            tool_executor=self.tool_executor,
+            options=AgentOptions(
+                max_rounds=max(1, int(self.options.max_turns or 1)),
+                tool_schemas=list(self.options.tool_schemas),
+            ),
+            remote_runner=self.remote_runner,
+            cancel_event=cancel_event,
+            tool_result_formatter=self.tool_result_formatter,
+        ):
+            if isinstance(event, AgentEventToken):
+                yield AriaMessage(kind="token", role="assistant", content=event.text)
+            elif isinstance(event, AgentEventThinking):
+                yield AriaMessage(kind="thinking", role="assistant", content=event.content)
+            elif isinstance(event, AgentEventToolCall):
+                yield AriaMessage(
+                    kind="tool_use",
+                    role="assistant",
+                    content=event.tool,
+                    data={"tool": event.tool, "params": dict(event.params)},
+                )
+            elif isinstance(event, AgentEventToolResult):
+                yield AriaMessage(
+                    kind="tool_result",
+                    role="tool",
+                    content=event.tool,
+                    data={
+                        "tool": event.tool,
+                        "result": dict(event.result),
+                        "elapsed": event.elapsed,
+                    },
+                )
+            elif isinstance(event, AgentEventStatus):
+                yield AriaMessage(
+                    kind="status",
+                    role="system",
+                    content=event.message,
+                    data={"state": event.state},
+                )
+            elif isinstance(event, AgentEventCancelled):
+                final_text = event.partial_text
+                yield AriaMessage(
+                    kind="result",
+                    role="assistant",
+                    content=final_text,
+                    data={
+                        "success": True,
+                        "cancelled": True,
+                        "provider": "runtime",
+                        "session_id": self.session_id,
+                    },
+                )
+            elif isinstance(event, AgentEventError):
+                yield AriaMessage(
+                    kind="result",
+                    role="assistant",
+                    content="",
+                    data={
+                        "success": False,
+                        "provider": "runtime",
+                        "session_id": self.session_id,
+                        "error": event.error,
+                    },
+                )
+            elif isinstance(event, AgentEventComplete):
+                final_text = event.result.final_text
+                if event.result.success:
+                    self.messages.extend([
+                        {"role": "user", "content": prompt},
+                        {"role": "assistant", "content": final_text},
+                    ])
+                yield AriaMessage(
+                    kind="assistant",
+                    role="assistant",
+                    content=final_text,
+                    data=event.result.to_dict(),
+                )
+                yield AriaMessage(
+                    kind="result",
+                    role="assistant",
+                    content=final_text,
+                    data={
+                        "success": event.result.success,
+                        "cancelled": event.result.cancelled,
+                        "provider": event.result.provider,
+                        "session_id": self.session_id,
+                        "tools": list(event.result.tools),
+                        "error": event.result.error,
+                    },
+                )
+
+    async def _run_llm(
+        self,
+        prompt: str,
+        *,
+        history: list,
+        cancel_event: asyncio.Event | None = None,
+    ) -> AsyncGenerator[AriaMessage, None]:
+        """Fallback to the configured LLM provider and normalize its events."""
+
+        selection = build_llm_provider(self.options)
+        provider = selection.provider
+        messages = list(history) + [{"role": "user", "content": prompt}]
+        token_parts: list[str] = []
+
+        try:
+            async for llm_event in provider.stream(messages, [], cancel_event=cancel_event):
+                if isinstance(llm_event, LLMToken):
+                    token_parts.append(llm_event.text)
+                    yield AriaMessage(kind="token", role="assistant", content=llm_event.text)
+                elif isinstance(llm_event, LLMThinking):
+                    yield AriaMessage(kind="thinking", role="assistant", content=llm_event.content)
+                elif isinstance(llm_event, LLMToolCall):
+                    yield AriaMessage(
+                        kind="tool_use",
+                        role="assistant",
+                        content=llm_event.tool,
+                        data={"tool": llm_event.tool, "params": dict(llm_event.params)},
+                    )
+                elif isinstance(llm_event, LLMToolResult):
+                    yield AriaMessage(
+                        kind="tool_result",
+                        role="tool",
+                        content=llm_event.summary,
+                        data={"tool": llm_event.tool, "summary": llm_event.summary},
+                    )
+                elif isinstance(llm_event, LLMStatus):
+                    yield AriaMessage(
+                        kind="status",
+                        role="system",
+                        content=llm_event.message,
+                        data={"state": llm_event.state},
+                    )
+                elif isinstance(llm_event, LLMDone):
+                    content = llm_event.response or "".join(token_parts)
+                    if llm_event.success:
+                        self.messages.extend([
+                            {"role": "user", "content": prompt},
+                            {"role": "assistant", "content": content},
+                        ])
+                    yield AriaMessage(
+                        kind="assistant",
+                        role="assistant",
+                        content=content,
+                        data={
+                            "provider": llm_event.provider,
+                            "usage": dict(llm_event.usage),
+                            "success": llm_event.success,
+                            "error": llm_event.error,
+                        },
+                    )
+                    yield AriaMessage(
+                        kind="result",
+                        role="assistant",
+                        content=content,
+                        data={
+                            "success": llm_event.success,
+                            "provider": llm_event.provider,
+                            "session_id": self.session_id,
+                            "error": llm_event.error,
+                        },
+                    )
+        except Exception as exc:
+            yield AriaMessage(
+                kind="result",
+                role="assistant",
+                content="",
+                data={
+                    "success": False,
+                    "provider": selection.name,
+                    "session_id": self.session_id,
+                    "error": str(exc),
+                },
+            )
+
+
+async def query(
+    prompt: str,
+    *,
+    options: AriaAgentOptions | None = None,
+    **overrides,
+) -> AsyncGenerator[AriaMessage, None]:
+    """Convenience async generator for one-off SDK calls."""
+
+    resolved_options = options or AriaAgentOptions()
+    if overrides:
+        resolved_options = replace(resolved_options, **overrides)
+    client = AriaSDKClient(resolved_options)
+    async for event in client.query(prompt):
+        yield event
+
+
+async def run(
+    prompt: str,
+    *,
+    options: AriaAgentOptions | None = None,
+    **overrides,
+) -> AriaResult:
+    """Collect a one-off SDK query and return the final result."""
+
+    final: AriaMessage | None = None
+    async for event in query(prompt, options=options, **overrides):
+        if event.kind == "result":
+            final = event
+    if final is None:
+        return AriaResult(success=False, error="no_result")
+    return AriaResult(
+        success=bool(final.data.get("success")),
+        content=final.content,
+        provider=str(final.data.get("provider") or ""),
+        session_id=str(final.data.get("session_id") or ""),
+        error=str(final.data.get("error") or ""),
+        data=dict(final.data),
+    )
+
+
+__all__ = [
+    "AriaSDKClient",
+    "query",
+    "run",
+]

packages/aria_sdk/providers.py

@@ -0,0 +1,70 @@
+"""Provider selection for the public Aria SDK."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from apps.cli.providers.base import AriaSSEProvider, LLMProvider, OllamaProvider
+
+from .types import AriaAgentOptions
+
+
+@dataclass(frozen=True)
+class ProviderSelection:
+    """Resolved provider instance and normalized provider name."""
+
+    name: str
+    provider: LLMProvider
+
+
+def normalize_provider_name(name: str) -> str:
+    key = (name or "auto").strip().lower().replace("-", "_")
+    aliases = {
+        "local": "ollama",
+        "ollama_local": "ollama",
+        "cloud": "aria_sse",
+        "remote": "aria_sse",
+        "sse": "aria_sse",
+        "aria": "aria_sse",
+    }
+    return aliases.get(key, key)
+
+
+def build_llm_provider(options: AriaAgentOptions) -> ProviderSelection:
+    """Build the configured LLM provider for SDK turns."""
+
+    requested = normalize_provider_name(options.provider)
+    if requested == "auto":
+        requested = "ollama" if options.local_mode else "aria_sse"
+
+    if requested == "ollama":
+        return ProviderSelection(
+            name="ollama",
+            provider=OllamaProvider(
+                options.ollama_url,
+                options.model,
+                system_override=options.system_prompt or None,
+            ),
+        )
+
+    if requested == "aria_sse":
+        return ProviderSelection(
+            name="aria_sse",
+            provider=AriaSSEProvider(
+                options.api_url,
+                options.model,
+                auth_token=options.auth_token or None,
+                thinking_mode=options.thinking_mode,
+                user_context=dict(options.user_context),
+                system_override=options.system_prompt or None,
+            ),
+        )
+
+    raise ValueError(f"Unsupported SDK provider: {options.provider}")
+
+
+__all__ = [
+    "ProviderSelection",
+    "build_llm_provider",
+    "normalize_provider_name",
+]