aria-code 0.167.0__py3-none-win_amd64.whl

aria_code/agents/warehouse/navigation.schema.json

@@ -0,0 +1,110 @@
+{
+  "type": "object",
+  "properties": {
+    "action": {
+      "type": "string",
+      "enum": [
+        "health",
+        "create",
+        "start",
+        "status",
+        "wait",
+        "stop",
+        "obstacle",
+        "trace"
+      ]
+    },
+    "goal": {
+      "type": "string",
+      "description": "User's task goal and constraints, as context; never a shell command."
+    },
+    "scenario": {
+      "type": "object",
+      "properties": {
+        "width": {
+          "type": "integer"
+        },
+        "height": {
+          "type": "integer"
+        },
+        "start": {
+          "type": "array",
+          "items": {
+            "type": "integer"
+          },
+          "minItems": 2,
+          "maxItems": 2
+        },
+        "goal": {
+          "type": "array",
+          "items": {
+            "type": "integer"
+          },
+          "minItems": 2,
+          "maxItems": 2
+        },
+        "obstacles": {
+          "type": "array",
+          "items": {
+            "type": "array",
+            "items": {
+              "type": "integer"
+            },
+            "minItems": 2,
+            "maxItems": 2
+          }
+        }
+      },
+      "required": [
+        "width",
+        "height",
+        "start",
+        "goal",
+        "obstacles"
+      ],
+      "additionalProperties": false
+    },
+    "constraints": {
+      "type": "object",
+      "properties": {
+        "max_steps": {
+          "type": "integer",
+          "minimum": 1,
+          "maximum": 512
+        },
+        "deadline_ms": {
+          "type": "integer",
+          "minimum": 100,
+          "maximum": 120000
+        }
+      },
+      "additionalProperties": false
+    },
+    "task_id": {
+      "type": "string"
+    },
+    "request_id": {
+      "type": "string",
+      "description": "Required only for create/start/obstacle. Stable unique operation ID; reuse only for an identical operation. Omit for health/status/wait/stop/trace."
+    },
+    "cell": {
+      "type": "array",
+      "items": {
+        "type": "integer"
+      },
+      "minItems": 2,
+      "maxItems": 2
+    },
+    "timeout_ms": {
+      "type": "integer",
+      "minimum": 0,
+      "maximum": 1000,
+      "description": "Required only for wait. Maximum 1000ms per call; query again if still running."
+    }
+  },
+  "required": [
+    "action"
+  ],
+  "additionalProperties": false,
+  "description": "Goal-directed logical warehouse simulation. Use only fields applicable to the selected action. create: action, request_id, goal, scenario, optional constraints. start: action, task_id, request_id. status/stop/trace: action, task_id ONLY. wait: action, task_id, timeout_ms ONLY. obstacle: action, task_id, request_id, cell. health: action ONLY. Never send request_id to read actions."
+}

aria_code/agents/warehouse/task_agent.py

@@ -0,0 +1,172 @@
+"""Stateful warehouse task agent capability; reasoning stays in Aria's model.
+
+This is a thin process adapter, not another Python planner or control loop.
+The native agent owns execution state and feedback-driven route decisions.
+"""
+from __future__ import annotations
+
+import atexit
+import json
+import os
+from pathlib import Path
+import queue
+import re
+import subprocess
+import threading
+from typing import Any
+
+SCHEMA = json.loads(Path(__file__).with_name('navigation.schema.json').read_text())
+DESCRIPTION = (
+    "Delegate a bounded warehouse navigation simulation to the warehouse task agent. "
+    "Use action=create with the user's goal, a known or explicitly requested demo scenario, "
+    "constraints and a unique request_id. Then start once with task_id/request_id and "
+    "use wait (timeout_ms <= 1000) or status until terminal. The native agent observes, "
+    "plans, moves, replans after obstacles, and verifies the goal itself. "
+    "Actions: health, create, start, status, wait, stop, obstacle, trace. "
+    "Never report completion from a start acknowledgement: require completed and verified=true. "
+    "Simulation only; no hardware, real warehouse sensing, or paid inference in the executor."
+)
+WORKFLOW_KNOWLEDGE = """Warehouse task agent workflow:
+- Understand the user's goal, map, destination and constraints. Ask for missing real-world data;
+  use synthetic scenes only when the user requested a demo/simulation. Never invent a real map.
+- Delegate a mission through warehouse_task. Preserve the returned task_id and request IDs.
+- Send request_id only with create/start/obstacle. For status/stop/trace send only action
+  and task_id; wait also requires timeout_ms (0–1000). Never add request_id to read actions.
+- The native agent selects and updates routes from current feedback; do not issue one model
+  call per grid cell or tell the user to manually chain low-level APIs.
+- Start is an acknowledgement, not success. Wait/status until completed, stopped, failed or
+  needs_input. Only completed + verified=true proves the goal was reached.
+- On needs_input, explain the actual obstacle/constraint and ask for the user's decision;
+  do not silently widen the goal or restart an unsuccessful task with larger budgets.
+- Honor stop requests. Review actual world/trace/metrics before reporting results.
+- This capability is a logical simulation, not a connected robot or physics simulator.
+"""
+
+
+def is_navigation_task(message: str) -> bool:
+    return bool(re.search(
+        r'warehouse_task|warehouse.{0,40}(?:navigat|robot|shelf|simulation)|'
+        r'\b(?:navigation|physical simulation)\b|仓库.{0,20}(?:导航|机器人|仿真)|'
+        r'(?:送|运|移动|导航).{0,25}(?:货架|货位)|(?:导航|仓储)仿真',
+        str(message or ''), re.I,
+    ))
+
+
+def _binary() -> tuple[str, list[str]]:
+    configured = os.environ.get('ARIA_PHYSICAL_BINARY')
+    if configured:
+        path = Path(configured).expanduser()
+        if not path.is_file():
+            raise RuntimeError('Configured ARIA_PHYSICAL_BINARY is missing')
+        return str(path), ['physical'] if path.name.startswith('aria-native') else []
+    from aria_code.runtime.native_index import native_binary
+    candidate = native_binary()
+    if candidate:
+        return candidate, ['physical']
+    root = Path(__file__).resolve().parents[4]
+    suffix = '.exe' if os.name == 'nt' else ''
+    candidate = root / 'rust' / 'target' / 'debug' / ('aria-physical' + suffix)
+    if candidate.is_file():
+        return str(candidate), []
+    raise RuntimeError('Native warehouse task agent is not installed; build aria-physical and configure the host ARIA_PHYSICAL_BINARY')
+
+
+class _NativeAgent:
+    def __init__(self):
+        binary, prefix = _binary()
+        env = {key: value for key, value in os.environ.items()
+               if key.upper() in {'PATH', 'SYSTEMROOT', 'WINDIR', 'TMP', 'TEMP', 'TMPDIR'}}
+        self.process = subprocess.Popen([binary, *prefix, 'agent-jsonl'], stdin=subprocess.PIPE,
+                                        stdout=subprocess.PIPE, stderr=subprocess.DEVNULL,
+                                        text=True, encoding='utf-8', env=env)
+        self.lock = threading.Lock()
+        self.responses: queue.Queue = queue.Queue(maxsize=16)
+        def read():
+            while True:
+                line = self.process.stdout.readline(1_048_577)
+                if not line or len(line) > 1_048_576:
+                    self.responses.put(None)
+                    break
+                self.responses.put(line)
+        self.reader = threading.Thread(target=read, daemon=True)
+        self.reader.start()
+        check = self.call({'action': 'health'})
+        if not check.get('ok') or check.get('result', {}).get('protocol') != 'warehouse-task-agent-v1':
+            self.close()
+            raise RuntimeError('Installed native binary does not support the warehouse task agent')
+
+    def call(self, params: dict) -> dict:
+        raw = json.dumps(params, ensure_ascii=True, allow_nan=False)
+        if len(raw.encode()) + 1 > 65536:
+            raise ValueError('Task request exceeds 64 KiB')
+        with self.lock:
+            try:
+                self.process.stdin.write(raw + '\n')
+                self.process.stdin.flush()
+                line = self.responses.get(timeout=5)
+                if line is None:
+                    raise RuntimeError('Native agent disconnected; task state is unknown')
+                result = json.loads(line)
+                if not isinstance(result, dict) or not isinstance(result.get('ok'), bool):
+                    raise ValueError('Unexpected native agent response')
+                return result
+            except (OSError, queue.Empty, ValueError) as exc:
+                # Never transparently restart/retry an uncertain mutation.
+                self.close()
+                raise RuntimeError('Native agent unavailable; task state is unknown, action not retried') from exc
+
+    def close(self):
+        if self.process.poll() is None:
+            try:
+                self.process.stdin.close()
+                self.process.wait(timeout=1)
+            except (OSError, subprocess.TimeoutExpired):
+                self.process.terminate()
+                try:
+                    self.process.wait(timeout=1)
+                except subprocess.TimeoutExpired:
+                    self.process.kill()
+                    self.process.wait(timeout=1)
+        if self.process.stdout:
+            self.process.stdout.close()
+
+
+class WarehouseTaskAgent:
+    """One native task-agent process per trusted Aria conversation context."""
+    name = 'warehouse_navigation'
+    capabilities = ('goal_contract', 'observe', 'plan', 'execute', 'replan', 'verify', 'stop')
+
+    def __init__(self):
+        self._agents: dict[str, _NativeAgent] = {}
+        self._lock = threading.Lock()
+
+    def handle(self, params: dict[str, Any]) -> dict:
+        scope = params.get('_warehouse_scope')
+        if not isinstance(scope, str) or not scope:
+            return {'success': False, 'error': 'Trusted host conversation scope is required'}
+        public = {k: v for k, v in params.items() if not k.startswith('_')}
+        if params.get('_warehouse_read_only') and public.get('action') in {'create', 'start', 'obstacle'}:
+            return {'success': False, 'error': 'Task mutations are blocked in read-only mode'}
+        try:
+            with self._lock:
+                agent = self._agents.get(scope)
+                if agent is None:
+                    if len(self._agents) >= 16:
+                        return {'success': False, 'error': 'Task agent conversation capacity reached'}
+                    agent = _NativeAgent()
+                    self._agents[scope] = agent
+            result = agent.call(public)
+            return {'success': result['ok'], **result}
+        except (RuntimeError, ValueError, OSError) as exc:
+            return {'success': False, 'error': str(exc), 'task_state': 'unknown'}
+
+    def close(self):
+        for agent in self._agents.values():
+            agent.close()
+        self._agents.clear()
+
+
+WAREHOUSE_AGENT = WarehouseTaskAgent()
+atexit.register(WAREHOUSE_AGENT.close)
+WAREHOUSE_TOOLS = {'warehouse_task': (WAREHOUSE_AGENT.handle, DESCRIPTION)}
+WAREHOUSE_SCHEMAS = [{'name': 'warehouse_task', 'description': DESCRIPTION, 'parameters': SCHEMA}]

aria_code/agents/warehouse/workflow.py

@@ -0,0 +1,31 @@
+"""Executable read-only workflow for the warehouse ERP agent team."""
+
+from __future__ import annotations
+
+from typing import Any, Callable
+
+from aria_code.agents.team import AgentTeam, TeamResult
+from aria_code.clients.warehouse_erp_client import WarehouseERPClient
+
+from . import WAREHOUSE_SCHEME, WAREHOUSE_TEAM
+
+
+async def run_warehouse_analysis(
+    warehouse_id: str,
+    client: WarehouseERPClient | Any | None = None,
+    on_agent_done: Callable[[str, Any], None] | None = None,
+) -> tuple[TeamResult, dict[str, Any]]:
+    """Fetch one ERP snapshot and analyse it with the warehouse agent team."""
+    erp_client = client or WarehouseERPClient.from_env()
+    snapshot = await erp_client.fetch_snapshot(warehouse_id)
+    team = AgentTeam(
+        signal_scheme=WAREHOUSE_SCHEME,
+        on_agent_done=on_agent_done,
+        timeout_per_agent=20,
+    )
+    result = await team.run(
+        warehouse_id,
+        agents=list(WAREHOUSE_TEAM),
+        agent_data={agent_name: snapshot for agent_name in WAREHOUSE_TEAM},
+    )
+    return result, snapshot

aria_code/aliyun_data_client.py

@@ -0,0 +1,4 @@
+"""Compatibility import for :mod:`clients.aliyun_data_client`."""
+from importlib import import_module as _import_module
+import sys as _sys
+_sys.modules[__name__] = _import_module("clients.aliyun_data_client")

aria_code/apps/README.md

@@ -0,0 +1,12 @@
+# Aria Code Apps
+
+`apps/` contains product entrypoints. Keep business logic in `packages/` and
+make each app a thin adapter over service contracts.
+
+- `cli/`: interactive terminal client.
+- `daemon/`: local-first background gateway.
+- `channels/`: external channel adapters such as relay, Feishu, Telegram, and webhooks.
+
+Current implementation still lives mostly in root modules such as `aria_cli.py`.
+New work should add service code behind `packages/` first, then migrate app
+entrypoints here in small steps.

aria_code/apps/__init__.py

@@ -0,0 +1,2 @@
+"""Product entrypoints for Aria Code."""
+

aria_code/apps/channels/README.md

@@ -0,0 +1,9 @@
+# Channel Apps
+
+The chat channels moved to [`services/aria-bots`](../../../../services/aria-bots/README.md):
+the conversation layer, approvals and digests are `aria_bots.channels`, the bots
+are `aria_bots.feishu_bot` / `aria_bots.telegram_bot`. The modules here with the
+old names are shims.
+
+What is still here: `intake.py` (task intake for the CLI) and `tradingview.py`
+(the daemon's TradingView webhook), which go with the Python worker and daemon.

aria_code/apps/channels/__init__.py

@@ -0,0 +1,17 @@
+"""Aria channels — external entrypoints as structured-task producers."""
+
+from .registry import (
+    CHANNEL_TASK_SCHEMA,
+    ChannelSpec,
+    channel_map,
+    default_channels,
+    enabled_channels,
+)
+
+__all__ = [
+    "CHANNEL_TASK_SCHEMA",
+    "ChannelSpec",
+    "channel_map",
+    "default_channels",
+    "enabled_channels",
+]

aria_code/apps/channels/approvals.py

@@ -0,0 +1,11 @@
+"""Moved to services/aria-bots: this name imports :mod:`aria_bots.channels.approvals`."""
+from importlib import import_module as _import_module
+from importlib.util import find_spec as _find_spec
+from pathlib import Path as _Path
+import sys as _sys
+
+if _find_spec("aria_bots") is None:  # a source checkout run without installing it
+    _sys.path.extend(str(_p / "services/aria-bots/src") for _p in _Path(__file__).resolve().parents
+                     if (_p / "services/aria-bots/src/aria_bots").is_dir())
+
+_sys.modules[__name__] = _import_module("aria_bots.channels.approvals")

aria_code/apps/channels/conversation.py

@@ -0,0 +1,11 @@
+"""Moved to services/aria-bots: this name imports :mod:`aria_bots.channels.conversation`."""
+from importlib import import_module as _import_module
+from importlib.util import find_spec as _find_spec
+from pathlib import Path as _Path
+import sys as _sys
+
+if _find_spec("aria_bots") is None:  # a source checkout run without installing it
+    _sys.path.extend(str(_p / "services/aria-bots/src") for _p in _Path(__file__).resolve().parents
+                     if (_p / "services/aria-bots/src/aria_bots").is_dir())
+
+_sys.modules[__name__] = _import_module("aria_bots.channels.conversation")

aria_code/apps/channels/digest.py

@@ -0,0 +1,11 @@
+"""Moved to services/aria-bots: this name imports :mod:`aria_bots.channels.digest`."""
+from importlib import import_module as _import_module
+from importlib.util import find_spec as _find_spec
+from pathlib import Path as _Path
+import sys as _sys
+
+if _find_spec("aria_bots") is None:  # a source checkout run without installing it
+    _sys.path.extend(str(_p / "services/aria-bots/src") for _p in _Path(__file__).resolve().parents
+                     if (_p / "services/aria-bots/src/aria_bots").is_dir())
+
+_sys.modules[__name__] = _import_module("aria_bots.channels.digest")

aria_code/apps/channels/intake.py

@@ -0,0 +1,92 @@
+"""Channel intake policy + gateway submission (the daemon-facing half).
+
+Completes the channels contract loop: the daemon's webhook endpoint hands
+verified channel tasks to ``runtime.run_turn`` instead of poking CLI
+internals, and refuses unauthenticated ("open mode") intake from anywhere
+but localhost.
+
+Two pieces, both dependency-light so the daemon can import them without
+dragging in aria_cli:
+
+  • should_refuse_open_intake() — pure policy: when neither an intake token
+    nor ARIA_WEBHOOK_SECRET is configured, only loopback clients may submit.
+  • analyze_alert_via_gateway() — submits a task prompt through the shared
+    runtime gateway with an EMPTY tool set: channel-triggered turns get
+    model analysis but can never execute tools from the daemon context.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Callable, Dict, Optional
+
+_LOOPBACK_HOSTS = {"127.0.0.1", "::1", "localhost"}
+
+
+def should_refuse_open_intake(
+    client_host: Optional[str],
+    *,
+    token_configured: bool,
+    secret_configured: bool,
+) -> bool:
+    """True when an unauthenticated intake must be rejected.
+
+    With any credential configured (endpoint token or webhook passphrase),
+    authentication handles trust and remote clients are fine. With neither
+    configured the endpoint is running "open", which is only acceptable from
+    the loopback interface — an open endpoint reachable off-host would let
+    anyone on the network inject buy/sell alerts.
+    """
+    if token_configured or secret_configured:
+        return False
+    host = str(client_host or "").strip().lower()
+    if host.startswith("[") and host.endswith("]"):  # bracketed IPv6
+        host = host[1:-1]
+    return host not in _LOOPBACK_HOSTS
+
+
+async def analyze_alert_via_gateway(
+    prompt: str,
+    config: Dict[str, Any],
+    *,
+    run_turn_fn: Optional[Callable] = None,
+    max_rounds: int = 4,
+) -> str:
+    """Run one tool-less analysis turn for a channel task; returns the text.
+
+    ``run_turn_fn`` is injectable for tests; the default builds the same
+    provider selection the CLI uses (chat_routing via runtime_bridge) and
+    drives ``runtime.gateway.run_turn``. Raises on failure — the caller
+    decides its own fallback (the daemon keeps its legacy quick summary).
+    """
+    if run_turn_fn is None:
+        # No `import aria_cli` here any more. It was unconditional, for the sake
+        # of the Ollama path's rebind, and cost 1766ms against the 63ms this
+        # module's own dependencies need — paid by every channel alert including
+        # the ones analysed through the cloud, which never reach stream_ollama.
+        # runtime_bridge now imports it inside the ollama branch, so the cost
+        # follows the route that needs it.
+        from apps.cli.providers.runtime_bridge import build_tool_executor, make_provider_fn
+        from runtime.gateway import run_turn as run_turn_fn_impl
+
+        provider_fn = make_provider_fn(
+            model=str(config.get("model", "qwen2.5:7b")),
+            config=config,
+            api_url=config.get("api_url"),
+            ollama_url=str(config.get("ollama_url", "http://localhost:11434")),
+            tool_schemas=[],
+        )
+        executor = build_tool_executor({}, config)
+
+        async def run_turn_fn(prompt_, history_, **kw):
+            return await run_turn_fn_impl(
+                prompt_, history_,
+                provider_fn=provider_fn, tool_executor=executor,
+                tool_schemas=[], max_rounds=max_rounds,
+            )
+
+    result = await run_turn_fn(prompt, [])
+    text = (getattr(result, "text", "") or "").strip()
+    error = getattr(result, "error", None)
+    if error or not text:
+        raise RuntimeError(f"gateway turn failed: {error or 'empty response'}")
+    return text

aria_code/apps/channels/registry.py

@@ -0,0 +1,11 @@
+"""Moved to services/aria-bots: this name imports :mod:`aria_bots.channels.registry`."""
+from importlib import import_module as _import_module
+from importlib.util import find_spec as _find_spec
+from pathlib import Path as _Path
+import sys as _sys
+
+if _find_spec("aria_bots") is None:  # a source checkout run without installing it
+    _sys.path.extend(str(_p / "services/aria-bots/src") for _p in _Path(__file__).resolve().parents
+                     if (_p / "services/aria-bots/src/aria_bots").is_dir())
+
+_sys.modules[__name__] = _import_module("aria_bots.channels.registry")

aria_code/apps/channels/tradingview.py

@@ -0,0 +1,94 @@
+"""TradingView alert → structured channel task (aria.channel_task.v1).
+
+The channels contract requires external entrypoints to submit *structured
+tasks* to the gateway instead of poking CLI internals. This adapter turns a
+raw TradingView webhook payload into that task shape, reusing the hardened
+primitives that already live in apps/cli/tradingview_bridge.py (field-tolerant
+parsing, passphrase + HMAC verification, dedup keys).
+
+Verification posture mirrors the bridge's documented semantics: with
+ARIA_WEBHOOK_SECRET unset verification is open (localhost-only assumption),
+but the task carries explicit ``verified`` / ``open_mode`` flags so a
+downstream gate (daemon, SafetyService) can refuse open-mode tasks in
+non-local deployments.
+"""
+
+from __future__ import annotations
+
+import time
+from typing import Any, Callable, Dict, Optional
+
+from aria_code.apps.cli.tradingview_bridge import (
+    _alert_dedup_key as alert_dedup_key,
+    _expected_webhook_secret,
+    parse_tradingview_alert,
+    verify_webhook_hmac,
+    verify_webhook_secret,
+)
+from aria_code.apps.channels.registry import CHANNEL_TASK_SCHEMA
+
+
+def alert_to_task(
+    payload: Dict[str, Any] | str,
+    *,
+    raw_body: Optional[bytes | str] = None,
+    signature: Optional[str] = None,
+    clock: Callable[[], float] = time.time,
+) -> Dict[str, Any]:
+    """Normalize + authenticate one webhook delivery.
+
+    Returns ``{"success": True, "task": {...}}`` or
+    ``{"success": False, "error": ...}`` (tool-result convention).
+    """
+    alert = parse_tradingview_alert(payload)
+    raw = alert.get("raw") or {}
+
+    secret_configured = bool(_expected_webhook_secret())
+    if signature is not None:
+        # A fronting signer supplied an HMAC — it must verify (never open).
+        if not verify_webhook_hmac(raw_body if raw_body is not None else "", signature):
+            return {"success": False, "error": "tradingview alert rejected: HMAC signature mismatch"}
+        verified = True
+    else:
+        if not verify_webhook_secret(raw):
+            return {"success": False, "error": "tradingview alert rejected: passphrase missing or wrong"}
+        verified = secret_configured  # open mode when no secret is configured
+
+    if not alert.get("symbol"):
+        return {"success": False, "error": "tradingview alert rejected: no symbol in payload"}
+
+    task = {
+        "schema": CHANNEL_TASK_SCHEMA,
+        "channel": "tradingview",
+        "kind": "alert",
+        "received_at": clock(),
+        "verified": verified,
+        "open_mode": not secret_configured and signature is None,
+        "dedup_key": alert_dedup_key(alert),
+        "symbol": alert["symbol"],
+        "action": alert["action"],
+        "price": alert.get("price"),
+        "time": alert.get("time"),
+        "message": alert.get("message") or "",
+        "prompt": task_prompt(alert),
+    }
+    return {"success": True, "task": task}
+
+
+def task_prompt(alert: Dict[str, Any]) -> str:
+    """Render the gateway-facing natural-language task for this alert.
+
+    The daemon submits this prompt to runtime's ``run_turn`` — the agent then
+    analyses the alert with its normal tools; nothing here places orders.
+    """
+    symbol = alert.get("symbol", "")
+    action = alert.get("action", "ALERT")
+    price = alert.get("price")
+    at = f" at {price}" if price not in (None, "") else ""
+    msg = str(alert.get("message") or "").strip()
+    tail = f' Alert message: "{msg}".' if msg else ""
+    return (
+        f"TradingView alert received: {action} signal for {symbol}{at}.{tail} "
+        f"Assess the signal against current market data and the portfolio, and "
+        f"summarize whether it warrants action. Do not place any orders."
+    )

aria_code/apps/cli/README.md

@@ -0,0 +1,13 @@
+# CLI App
+
+Target role: terminal UI and command parsing only.
+
+The CLI should depend on these services:
+
+- `gateway`: session routing and task orchestration.
+- `runtime`: agent loop and tool execution.
+- `ui`: terminal rendering and input.
+- `reports`: local artifact and report output.
+
+Migration rule: new slash commands should call package services instead of
+adding more business logic to `aria_cli.py`.

aria_code/apps/cli/__init__.py

@@ -0,0 +1,2 @@
+"""Terminal client entrypoint and adapters for Aria Code."""
+