aria-code 0.52.0__py3-none-any.whl

aria_code/agents/registry.py

@@ -0,0 +1,158 @@
+"""
+agents/registry.py — Agent 注册与自动发现
+==========================================
+1. 内置 agent 预注册（technical / fundamental / macro / risk）
+2. 扫描 ./aria_agents/ → 自动注册用户自定义 agent
+3. 提供 get() / list() / register() 接口
+
+自定义 Agent 放置规则:
+    项目根/aria_agents/my_agent.py
+    类需继承 BaseAgent，且声明 name 属性
+"""
+
+from __future__ import annotations
+
+import importlib.util
+import inspect
+import logging
+import sys
+from pathlib import Path
+from typing import Dict, List, Optional, Type
+
+from .base import BaseAgent
+from .financial.technical import TechnicalAgent
+
+logger = logging.getLogger(__name__)
+
+# ── 内置 agent 预注册 ─────────────────────────────────────────────────────────
+_BUILTIN: Dict[str, Type[BaseAgent]] = {
+    "technical": TechnicalAgent,
+}
+
+# 尝试加载其他内置 agent（文件存在则注册）
+def _try_import_builtin(module_path: str, name: str) -> None:
+    try:
+        parts = module_path.split(".")
+        mod = importlib.import_module(module_path)
+        for _, cls in inspect.getmembers(mod, inspect.isclass):
+            if issubclass(cls, BaseAgent) and cls is not BaseAgent:
+                _BUILTIN[cls.name] = cls
+    except ImportError:
+        pass
+
+
+_try_import_builtin("aria_code.agents.financial.macro",       "macro")
+_try_import_builtin("aria_code.agents.financial.fundamental",  "fundamental")
+_try_import_builtin("aria_code.agents.financial.risk",         "risk")
+_try_import_builtin("aria_code.agents.financial.synthesis",    "synthesis")
+_try_import_builtin("aria_code.agents.financial.news",         "news")
+_try_import_builtin("aria_code.agents.financial.catalyst",     "catalyst")
+_try_import_builtin("aria_code.agents.financial.debate",       "debate")
+_try_import_builtin("aria_code.agents.financial.earnings",     "earnings")
+_try_import_builtin("aria_code.agents.financial.sector",       "sector")
+_try_import_builtin("aria_code.agents.financial.strategist",   "strategist")
+_try_import_builtin("aria_code.agents.engineering.coder",      "coder")
+_try_import_builtin("aria_code.agents.engineering.tester",     "tester")
+_try_import_builtin("aria_code.agents.financial.corporate_finance", "corporate_finance")
+_try_import_builtin("aria_code.agents.financial.cashflow_burn",     "cashflow_burn")
+_try_import_builtin("aria_code.agents.financial.stripe_revenue",    "stripe_revenue")
+_try_import_builtin("aria_code.agents.portfolio_agent",        "portfolio")
+_try_import_builtin("aria_code.agents.supervisor",             "supervisor")
+
+# ── 经营权共创平台 Agent 包 ────────────────────────────────────────────────────
+_try_import_builtin("aria_code.agents.realty.asset_diagnosis",  "asset_diagnosis")
+_try_import_builtin("aria_code.agents.realty.business_match",   "business_match")
+_try_import_builtin("aria_code.agents.realty.contract_rules",   "contract_rules")
+_try_import_builtin("aria_code.agents.realty.revenue_share",    "revenue_share")
+_try_import_builtin("aria_code.agents.realty.cashflow_verify",  "cashflow_verify")
+_try_import_builtin("aria_code.agents.realty.energy_anomaly",   "energy_anomaly")
+_try_import_builtin("aria_code.agents.realty.fulfillment_risk", "fulfillment_risk")
+_try_import_builtin("aria_code.agents.realty.ops_optimize",     "ops_optimize")
+_try_import_builtin("aria_code.agents.realty.exit_settlement",  "exit_settlement")
+
+# ── 海外仓与物流供应链 Agent 包 ──────────────────────────────────────────────────
+_try_import_builtin("aria_code.agents.warehouse.logistics_sync", "warehouse_logistics_sync")
+_try_import_builtin("aria_code.agents.warehouse.inbound_exceptions", "warehouse_inbound_exceptions")
+_try_import_builtin("aria_code.agents.warehouse.inventory_health", "warehouse_inventory_health")
+_try_import_builtin("aria_code.agents.warehouse.logistics_cost", "warehouse_logistics_cost")
+_try_import_builtin("aria_code.agents.warehouse.fulfillment_leadtime", "warehouse_fulfillment_leadtime")
+
+
+class AgentRegistry:
+    """
+    Agent 注册中心（单例）。
+
+    用法:
+        registry = get_registry()
+        registry.register(MyAgent)
+        agent_cls = registry.get("my_agent")
+    """
+
+    def __init__(self):
+        self._agents: Dict[str, Type[BaseAgent]] = dict(_BUILTIN)
+        self._scanned = False
+
+    def register(self, cls: Type[BaseAgent]) -> None:
+        """手动注册一个 Agent 类"""
+        if not (isinstance(cls, type) and issubclass(cls, BaseAgent)):
+            raise TypeError(f"{cls} 不是 BaseAgent 子类")
+        self._agents[cls.name] = cls
+        logger.info(f"✓ 注册 Agent: {cls.name}")
+
+    def get(self, name: str) -> Optional[Type[BaseAgent]]:
+        """按名称获取 Agent 类"""
+        self._ensure_scanned()
+        return self._agents.get(name.lower())
+
+    def list(self) -> List[Dict]:
+        """列出所有已注册 Agent"""
+        self._ensure_scanned()
+        return [
+            {"name": name, "description": cls.description, "builtin": name in _BUILTIN}
+            for name, cls in self._agents.items()
+        ]
+
+    def _ensure_scanned(self) -> None:
+        if not self._scanned:
+            self._scan_project()
+            self._scanned = True
+
+    def _scan_project(self) -> None:
+        """扫描当前工作目录及父级的 aria_agents/ 目录"""
+        search_paths = [Path.cwd(), Path.cwd().parent]
+        for base in search_paths:
+            agents_dir = base / "aria_agents"
+            if not agents_dir.is_dir():
+                continue
+            for py_file in sorted(agents_dir.glob("*.py")):
+                if py_file.name.startswith("_"):
+                    continue
+                self._load_file(py_file)
+            break   # 找到第一个 aria_agents/ 即停止向上搜索
+
+    def _load_file(self, path: Path) -> None:
+        """加载一个 .py 文件，自动注册其中的 BaseAgent 子类"""
+        try:
+            spec   = importlib.util.spec_from_file_location(path.stem, path)
+            module = importlib.util.module_from_spec(spec)
+            spec.loader.exec_module(module)
+            for _, cls in inspect.getmembers(module, inspect.isclass):
+                if (cls.__module__ == module.__name__
+                        and issubclass(cls, BaseAgent)
+                        and cls is not BaseAgent
+                        and hasattr(cls, "name")
+                        and cls.name != "base"):
+                    self._agents[cls.name] = cls
+                    logger.info(f"✓ 自动发现 Agent: {cls.name} ({path.name})")
+        except Exception as e:
+            logger.warning(f"加载 agent 文件 {path} 失败: {e}")
+
+
+# ── 单例 ──────────────────────────────────────────────────────────────────────
+_registry: Optional[AgentRegistry] = None
+
+def get_registry() -> AgentRegistry:
+    global _registry
+    if _registry is None:
+        _registry = AgentRegistry()
+    return _registry

aria_code/agents/signal_scheme.py

@@ -0,0 +1,111 @@
+"""
+agents/signal_scheme.py — 领域可插拔的信号词汇表
+====================================================
+team.py 里的表决(_vote_signal)、辩论触发(_needs_debate)原本硬编码了金融的
+BUY/HOLD/SELL/STRONG_BUY/STRONG_SELL 五级词汇。realty 的 9 个 agent 长期以来
+借用同一套词汇表达完全不同的含义(BUY=推荐共创、流水真实、条款清晰、低风险……
+每个文件的 BUY 意思都不一样，只在各自 docstring 里注明)，靠 aria_cli.py 里
+一张 _SIGNAL_LABELS 翻译表在展示层补救。这意味着一旦有人把多个 realty agent
+接进 AgentTeam 做 vote/debate（cashflow_verify 的 SELL=疑似造假 和
+ops_optimize 的 SELL=经营不佳需干预 完全不是同一个维度），_vote_signal 会把
+它们当同一根多空轴数值平均，产出一个语义上没有意义的"共识"。
+
+SignalScheme 把这套词汇表和打分/辩论触发规则抽成领域可配置的对象，
+AgentTeam 默认用 FINANCIAL_SCHEME（对现有金融调用方零行为变化），
+其他领域注册自己的词汇表即可复用同一套并行/表决/辩论/synthesis 编排逻辑，
+而不必借用金融的 BUY/SELL 语义或答案词不达意。
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Dict, List, Tuple
+
+from .base import AgentResult
+
+
+@dataclass(frozen=True)
+class SignalScheme:
+    """一套领域信号词汇表：多空打分 + 辩论触发条件。
+
+    upper_thresholds / lower_thresholds 特意分成两条腿而不是一条单向扫描的
+    区间列表——原始金融判定逻辑本身就是两段非对称的边界（上方 >= 含右端点，
+    下方 <= 含左端点，中间落空隙才算 neutral_default），一条单向 >= 扫描的
+    区间列表没法同时正确表达"上方含端点"和"下方也含端点"这两种边界方向，
+    会把 avg_score=0 这种中性分数错误地吃进最负的那个区间（已在 fuzz 测试里
+    实测过这个 bug：单向列表版本对 avg_score=0 的输入返回了 STRONG_SELL）。
+    """
+
+    name: str
+    # 信号 → 打分（用于表决时按置信度加权平均）；分数越高越"正面"。
+    scores: Dict[str, int]
+    # 从高到低排列；第一个满足 avg_score >= threshold 的胜出。
+    upper_thresholds: List[Tuple[float, str]]
+    # 按"最极端优先"排列（比如先检查 <=-1.5 再检查 <=-0.5）；
+    # 第一个满足 avg_score <= threshold 的胜出。
+    lower_thresholds: List[Tuple[float, str]]
+    # 触发 debate 的两组信号（出现其一 + 另一组其一即触发，比如金融的"多"与"空"）
+    positive_signals: frozenset
+    negative_signals: frozenset
+    neutral_default: str = "HOLD"
+
+    def vote(self, results: List[AgentResult]) -> Tuple[str, float]:
+        valid = [r for r in results if r.success and r.signal in self.scores]
+        if not valid:
+            return self.neutral_default, 0.0
+        avg_score = sum(self.scores[r.signal] * r.confidence for r in valid) / len(valid)
+        avg_conf = sum(r.confidence for r in valid) / len(valid)
+        for threshold, label in self.upper_thresholds:
+            if avg_score >= threshold:
+                return label, avg_conf
+        for threshold, label in self.lower_thresholds:
+            if avg_score <= threshold:
+                return label, avg_conf
+        return self.neutral_default, avg_conf
+
+    def needs_debate(self, results: List[AgentResult]) -> bool:
+        signals = [r.signal for r in results if r.success and r.signal]
+        has_positive = any(s in self.positive_signals for s in signals)
+        has_negative = any(s in self.negative_signals for s in signals)
+        return has_positive and has_negative
+
+
+# ── 金融：既有行为，原样保留（upper/lower 拆分精确复刻原 if/elif 分支）────────
+FINANCIAL_SCHEME = SignalScheme(
+    name="financial",
+    scores={"STRONG_BUY": 2, "BUY": 1, "HOLD": 0, "SELL": -1, "STRONG_SELL": -2},
+    upper_thresholds=[(1.5, "STRONG_BUY"), (0.5, "BUY")],
+    lower_thresholds=[(-1.5, "STRONG_SELL"), (-0.5, "SELL")],
+    positive_signals=frozenset({"BUY", "STRONG_BUY"}),
+    negative_signals=frozenset({"SELL", "STRONG_SELL"}),
+    neutral_default="HOLD",
+)
+
+# ── 地产资管：健康度评估，不是交易动作 ──────────────────────────────────────
+# GOOD/WATCH/CONCERN/SEVERE —— 这条轴描述"这个维度是否健康"，不是"要不要买"。
+# 9 个 realty agent 各自评估不同维度（流水真实性、合同风险、能耗异常、履约风险
+# 等），但共享同一个"健康 → 需关注 → 有问题 → 严重"的四级尺度，用领域自己的
+# 词汇表述比借用股票的 BUY/SELL 更准确，也让 vote/debate 的语义站得住脚。
+REALTY_SCHEME = SignalScheme(
+    name="realty",
+    scores={"GOOD": 2, "WATCH": 0, "CONCERN": -1, "SEVERE": -2},
+    upper_thresholds=[(1.0, "GOOD")],
+    lower_thresholds=[(-1.5, "SEVERE"), (-0.5, "CONCERN")],
+    positive_signals=frozenset({"GOOD"}),
+    negative_signals=frozenset({"CONCERN", "SEVERE"}),
+    neutral_default="WATCH",
+)
+
+# ── 仓储 ERP：同样是运营健康度，不是交易动作 ────────────────────────────────
+# Warehouse agents assess carrier synchronisation, inbound exceptions and stock
+# health.  Keeping a named scheme prevents callers from accidentally applying
+# the financial BUY/HOLD/SELL vote to these operational signals.
+WAREHOUSE_SCHEME = SignalScheme(
+    name="warehouse",
+    scores={"GOOD": 2, "WATCH": 0, "CONCERN": -1, "SEVERE": -2},
+    upper_thresholds=[(1.0, "GOOD")],
+    lower_thresholds=[(-1.5, "SEVERE"), (-0.5, "CONCERN")],
+    positive_signals=frozenset({"GOOD"}),
+    negative_signals=frozenset({"CONCERN", "SEVERE"}),
+    neutral_default="WATCH",
+)

aria_code/agents/sports/football_agent.py

@@ -0,0 +1,197 @@
+"""
+agents/sports/football_agent.py — Football Analysis Agent
+===========================================================
+LLM-powered football match analysis using Elo + Dixon-Coles prediction + form data.
+
+Prediction comes from packages.quant_engine.sports.predictor (Elo ratings,
+Dixon-Coles with negative-binomial tail for lopsided matches, dynamic
+Elo/DC mixing weights, recency-form and head-to-head adjustments, and
+self-calibration), not football_data_client.predict_match — that function
+is a much simpler independent-Poisson model over a static, hand-maintained
+attack/defense lookup table with a flat home-advantage constant, no
+Dixon-Coles low-score correlation correction, and no Elo. Verified the two
+disagree by double digits on some matchups (13.1pp on a real fixture) rather
+than assuming the richer model is worth switching to on faith.
+
+football_data_client itself is left untouched — aria_feishu_bot.py calls
+predict_match directly and has its own tested formatting/localization
+pinned to that function's exact output, which is out of scope here. Only
+get_team_stats() (recent-form text, not part of either prediction model)
+is still sourced from football_data_client.
+"""
+
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class MatchPrediction:
+    home_team:    str
+    away_team:    str
+    league:       str
+    home_win:     float
+    draw:         float
+    away_win:     float
+    btts:         float
+    lambda_home:  float
+    lambda_away:  float
+    most_likely:  str
+    top_scores:   List[Dict]
+    implied_odds: Dict[str, float]
+    analysis:     str = ""
+    key_factors:  List[str] = field(default_factory=list)
+
+    @property
+    def verdict(self) -> str:
+        probs = {"home": self.home_win, "draw": self.draw, "away": self.away_win}
+        winner = max(probs, key=probs.get)
+        dominant = probs[winner] > 0.50
+        if winner == "home":
+            return f"主队{'强势' if dominant else '略有'}优势 ({self.home_win:.0%})"
+        elif winner == "away":
+            return f"客队{'强势' if dominant else '略有'}优势 ({self.away_win:.0%})"
+        else:
+            return f"势均力敌，平局概率较高 ({self.draw:.0%})"
+
+
+class FootballAgent:
+    """
+    Football analysis combining Poisson prediction + LLM interpretation.
+    Can run standalone (no LLM) or enhanced with LLM narrative.
+    """
+
+    name = "football"
+    description = "足球赛事分析与预测 — 泊松模型 + 近期战绩 + xG数据"
+
+    def __init__(self, llm_call=None):
+        self._llm = llm_call  # Optional: async fn(prompt) -> str
+
+    async def predict(
+        self,
+        home_team: str,
+        away_team: str,
+        league: str = "pl",
+        with_llm: bool = True,
+        neutral_venue: bool = False,
+    ) -> MatchPrediction:
+        from football_data_client import get_team_stats
+        from packages.quant_engine.sports.predictor import quick_predict
+
+        # neutral_venue defaults False: club leagues (pl/bl1/sa/pd/fl1, the
+        # default `league="pl"`) really do have a home team playing at home.
+        # Pass True for a genuinely neutral-site fixture (e.g. a World Cup
+        # group match at a third country's stadium).
+        raw = quick_predict(home_team, away_team, league, neutral_venue=neutral_venue)
+        raw["most_likely_score"] = (
+            raw["top_scorelines"][0]["score"] if raw.get("top_scorelines") else "0-0"
+        )
+        h_stats = get_team_stats(league, home_team)
+        a_stats = get_team_stats(league, away_team)
+
+        key_factors = []
+        if h_stats:
+            key_factors.append(f"{home_team} 近5场: {h_stats['form']} (场均进球 {h_stats['avg_gf']})")
+        if a_stats:
+            key_factors.append(f"{away_team} 近5场: {a_stats['form']} (场均进球 {a_stats['avg_gf']})")
+        key_factors.append(
+            f"模型: {raw['model']}  Elo差: {raw['elo_diff']:+.0f}"
+            f"  (DC权重{raw['w_dc']:.0%}/Elo权重{raw['w_elo']:.0%})"
+        )
+
+        analysis = ""
+        if with_llm and self._llm:
+            prompt = _build_analysis_prompt(raw, h_stats, a_stats)
+            try:
+                analysis = await self._llm(prompt)
+            except Exception as exc:
+                logger.warning("LLM analysis failed: %s", exc)
+                analysis = _fallback_analysis(raw)
+        else:
+            analysis = _fallback_analysis(raw)
+
+        return MatchPrediction(
+            home_team=home_team,
+            away_team=away_team,
+            league=league,
+            home_win=raw["home_win"],
+            draw=raw["draw"],
+            away_win=raw["away_win"],
+            btts=raw["btts"],
+            lambda_home=raw["lambda_home"],
+            lambda_away=raw["lambda_away"],
+            most_likely=raw["most_likely_score"],
+            top_scores=raw["top_scorelines"],
+            implied_odds=raw["implied_odds"],
+            analysis=analysis,
+            key_factors=key_factors,
+        )
+
+
+def _fallback_analysis(raw: Dict) -> str:
+    hw, d, aw = raw["home_win"], raw["draw"], raw["away_win"]
+    lh, la = raw["lambda_home"], raw["lambda_away"]
+    ht, at = raw["home_team"], raw["away_team"]
+
+    lines = []
+    if hw > aw + 0.15:
+        lines.append(f"泊松模型显示 **{ht}** 主场优势明显（胜率 {hw:.0%}）")
+    elif aw > hw + 0.15:
+        lines.append(f"泊松模型显示 **{at}** 客场表现更强（胜率 {aw:.0%}）")
+    else:
+        lines.append(f"双方实力相当，平局可能性较大（{d:.0%}）")
+
+    lines.append(f"预期进球：{ht} {lh:.1f} / {at} {la:.1f}")
+    top = raw["top_scorelines"][:3]
+    score_str = " | ".join(f"{s['score']}({s['prob']}%)" for s in top)
+    lines.append(f"高概率比分：{score_str}")
+    btts = raw["btts"]
+    lines.append(f"双方均进球概率：{btts:.0%}")
+
+    return "\n".join(lines)
+
+
+def _build_analysis_prompt(raw: Dict, h_stats: Optional[Dict], a_stats: Optional[Dict]) -> str:
+    top_scores = "、".join(
+        f"{s['score']}({s['prob']}%)"
+        for s in raw.get("top_scorelines", [])[:5]
+    )
+    return f"""你是一位专业足球分析师。根据以下泊松预测模型数据，用中文分析这场比赛：
+
+【比赛】{raw['home_team']} vs {raw['away_team']}
+
+【预测概率】
+主队胜: {raw['home_win']:.1%}  平局: {raw['draw']:.1%}  客队胜: {raw['away_win']:.1%}
+预期进球: 主队 {raw['lambda_home']:.2f} / 客队 {raw['lambda_away']:.2f}
+最可能比分: {raw['most_likely_score']}
+候选比分（按模型概率降序）: {top_scores}
+双方均进球: {raw['btts']:.1%}
+
+【近期战绩】
+{_format_stats(raw['home_team'], h_stats)}
+{_format_stats(raw['away_team'], a_stats)}
+
+请提供:
+1. 比赛走势分析（3-4句）
+2. 关键影响因素（2-3条）
+3. 预测建议（1句话结论）
+
+规则:
+- 必须按“候选比分”概率顺序讨论比分，不要把低概率比分排到第一。
+- 不要编造射正率、历史交锋、最近5场客场等输入数据之外的具体数字。
+- 如果给出多个准确比分，直接引用候选比分及概率。
+
+简洁专业，不超过200字。"""
+
+
+def _format_stats(team: str, stats: Optional[Dict]) -> str:
+    if not stats:
+        return f"{team}: 数据不足"
+    return (
+        f"{team}: 近{stats['last_n']}场 {stats['w']}胜{stats['d']}平{stats['l']}负, "
+        f"进{stats['gf']}球失{stats['ga']}球, 近5场战绩: {stats['form']}"
+    )

aria_code/agents/supervisor.py

@@ -0,0 +1,113 @@
+"""
+agents/supervisor.py — 动态规划与路由 Agent
+===========================================
+负责根据用户意图和资产类型，动态挑选最合适的 Sub-agents 执行分析。
+"""
+
+import json
+import logging
+from typing import Any, Dict
+
+from .base import BaseAgent, AgentResult
+
+logger = logging.getLogger(__name__)
+
+class SupervisorAgent(BaseAgent):
+    name: str = "supervisor"
+    description: str = "动态规划与路由 Agent，决定应唤醒哪些子 Agent"
+
+    @staticmethod
+    def _fallback_selection(available: list[str]) -> list[str]:
+        """Choose a deterministic, registry-safe fallback team.
+
+        The Supervisor is optional infrastructure: losing its LLM response must
+        never cause ``AgentTeam`` to receive names that are absent from the
+        registry. Prefer the familiar financial specialists, then fill from
+        any remaining available read-only agents.
+        """
+        preferred = ["macro", "fundamental", "technical", "risk"]
+        chosen = [name for name in preferred if name in available]
+        for name in available:
+            if name not in chosen:
+                chosen.append(name)
+            if len(chosen) == 5:
+                break
+        return chosen[:5]
+
+    @classmethod
+    def _normalize_selection(cls, selected: Any, available: list[str]) -> list[str]:
+        """Validate model output and complete it with safe deterministic choices."""
+        if not isinstance(selected, list):
+            selected = []
+
+        allowed = set(available)
+        normalized: list[str] = []
+        for value in selected:
+            name = str(value or "").strip().lower()
+            if name in allowed and name not in normalized:
+                normalized.append(name)
+            if len(normalized) == 5:
+                break
+
+        # The prompt asks for 2–5 agents.  On a partial installation, use all
+        # available specialists rather than inventing an unavailable name.
+        minimum = min(2, len(available))
+        if len(normalized) < minimum:
+            for name in cls._fallback_selection(available):
+                if name not in normalized:
+                    normalized.append(name)
+                if len(normalized) >= minimum:
+                    break
+
+        return normalized[:5]
+
+    async def analyze(self, symbol: str, data: Dict[str, Any]) -> AgentResult:
+        from .registry import get_registry
+        registry = get_registry()
+        agents_info = [
+            info for info in registry.list()
+            if info["name"] not in ("supervisor", "synthesis", "debate", "base")
+        ]
+        available = [str(info["name"]).lower() for info in agents_info]
+
+        system_prompt = (
+            "You are the Supervisor Agent of a financial analysis system.\n"
+            "Your task is to select the most appropriate specialist agents to analyze the given asset.\n"
+            "Available agents:\n"
+        )
+        for info in agents_info:
+            system_prompt += f"- {info['name']}: {info['description']}\n"
+
+        system_prompt += (
+            "\nSelect between 2 to 5 agents that are best suited for this asset.\n"
+            "For example, do not select crypto agents for standard stocks, and do not select realty agents for equities.\n"
+            "Output a strict JSON object with a single key 'selected_agents' containing a list of strings (the names of the agents to run).\n"
+            "Do not include markdown blocks or any other text.\n"
+            "Example: {\"selected_agents\": [\"macro\", \"technical\"]}"
+        )
+
+        user_prompt = f"Analyze asset: {symbol}\n"
+        if data and "market_data_block" in data:
+            user_prompt += f"Context:\n{data['market_data_block']}\n"
+
+        response_text = await self._call_llm(system_prompt, user_prompt, max_tokens=200, quote=data.get("quote"))
+
+        selected: Any = []
+        try:
+            start = response_text.find('{')
+            end = response_text.rfind('}') + 1
+            if start != -1 and end != 0:
+                parsed = json.loads(response_text[start:end])
+                selected = parsed.get("selected_agents", [])
+        except Exception as e:
+            logger.warning(f"Supervisor json parse failed: {e}")
+
+        selected = self._normalize_selection(selected, available)
+
+        return AgentResult(
+            agent=self.name,
+            symbol=symbol,
+            analysis=json.dumps(selected),
+            confidence=1.0,
+            signal="HOLD",
+        )