aria-code 0.52.0__py3-none-any.whl

aria_code/packages/aria_mcp/tools.py

@@ -0,0 +1,81 @@
+"""Adapters from MCP tool descriptors to Aria tool manifests."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, Iterable, List
+
+from aria_code.packages.aria_core import PermissionLevel
+from aria_code.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 ("research_run", "artifact", "audit trail", "lifecycle")):
+        capabilities.append("research.lifecycle")
+    if "research_report" in text or "quality assessment" in text or "completion gate" in text:
+        capabilities.append("research.quality")
+    if any(word in text for word in ("health", "readiness", "dependency")):
+        capabilities.append("runtime.health")
+    if "execution_schedule" in text or "execution plan" in text:
+        capabilities.append("execution.analytics")
+    elif 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 = "",
+    annotations: Dict[str, Any] | None = None,
+) -> List[PermissionLevel]:
+    text = f"{name} {description}".lower()
+    if annotations and annotations.get("readOnlyHint") is True:
+        return [PermissionLevel.NETWORK]
+    if any(word in text for word in ("trade", "order", "execution")):
+        return [PermissionLevel.NETWORK, PermissionLevel.BROKER_TRADE]
+    if annotations and annotations.get("readOnlyHint") is False:
+        return [PermissionLevel.NETWORK, PermissionLevel.WORKSPACE_WRITE]
+    if any(word in text for word in (
+        "write", "export", "report", "backtest", "create", "transition",
+        "attach", "update", "delete", "approve", "cancel",
+    )):
+        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 {}
+    annotations = tool.get("annotations") if isinstance(tool.get("annotations"), dict) else {}
+    return ToolSpec(
+        name=qualified_name,
+        handler=None,
+        description=description,
+        schema=schema if isinstance(schema, dict) else {},
+        permissions=_permissions_for_mcp_tool(short_name, description, annotations),
+        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,
+    )

aria_code/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",
+]

aria_code/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 aria_code.apps.cli.deterministic import run_deterministic_chain
+from aria_code.apps.cli.providers.base import (
+    LLMDone,
+    LLMStatus,
+    LLMThinking,
+    LLMToken,
+    LLMToolCall,
+    LLMToolResult,
+)
+from aria_code.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",
+]

aria_code/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 aria_code.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",
+]

aria_code/packages/aria_sdk/streaming.py

@@ -0,0 +1,79 @@
+"""Provider streaming helpers shared by SDK and CLI adapters."""
+
+from __future__ import annotations
+
+import asyncio
+from typing import Callable
+
+from aria_code.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)
+    pending_tools = tool_calls or list(final.tool_calls_pending)
+    success = final.success
+    error = final.error
+    if success and not final.cancelled and not response.strip() and not pending_tools:
+        success = False
+        error = error or "empty_response"
+    return {
+        "success": success,
+        "response": response,
+        "provider": final.provider,
+        "tool_calls_pending": pending_tools,
+        "usage": dict(final.usage),
+        "cancelled": final.cancelled,
+        "error": error,
+    }
+
+
+__all__ = ["stream_provider_result"]