feat: 核心模块增强 — 加密 + 运行时配置 + 日志缓冲

- crypto.py: API Key 加密/解密工具
- runtime_config.py: 运行时动态配置管理
- log_buffer.py: 内存日志缓冲区
- config.py: 新增加密配置项
- http_client.py: 增强重试和错误处理

src/llm/agents/orchestrator.py

@@ -13,6 +13,7 @@ from src.core.config import settings
 from src.db.base import AsyncSessionLocal
 from src.db.models import Match, Prediction
 from src.db.unit_of_work import get_uow
+from src.llm.predict import _upsert_prediction
 from src.llm.agents.base import AgentReport, AgentSpec, load_agent_prompt
 from src.llm.context_builder import (
     MatchHeader,
@@ -24,6 +25,7 @@ from src.llm.context_builder import (
     load_match_header,
     stats_slice,
 )
+from src.core.runtime_config import get_runtime_value
 from src.llm.provider import LLMProvider, get_default_provider
 
 logger = logging.getLogger(__name__)
@@ -58,7 +60,20 @@ SPECIALIST_SPECS: list[AgentSpec] = [
     ),
 ]
 
-AGGREGATOR_SYSTEM = "你是足球预测终裁专家。综合各领域报告输出最终预测。只输出 JSON。"
+AGGREGATOR_SYSTEM = (
+    "你是足球预测终裁专家。综合各领域专家报告输出最终预测。"
+    "引用专家时必须使用报告中的专家全名(如「攻防数据分析专家」),禁止使用英文代码。"
+    "只输出 JSON。"
+)
+
+# 专家代码 → 终裁/展示统一称呼
+AGENT_LABELS_ZH: dict[str, str] = {
+    "form": "近期状态分析专家",
+    "stats": "攻防数据分析专家",
+    "home_away": "主客因素分析专家",
+    "injuries": "阵容完整性分析专家",
+    "h2h": "历史交锋分析专家",
+}
 
 
 @dataclass
@@ -70,6 +85,8 @@ class MultiPredictResult:
     mode: str
     pred_home_goals: float | None
     pred_away_goals: float | None
+    alt_pred_home_goals: int | None
+    alt_pred_away_goals: int | None
     pred_1x2: str | None
     subjective_confidence: float | None
     reasoning: str | None
@@ -80,31 +97,38 @@ class MultiPredictResult:
     raw: dict | None
 
 
-def _get_specialist_provider() -> LLMProvider:
-    """专家模型: LLM_SPECIALIST_MODEL 回落 LLM_MODEL。"""
-    p = get_default_provider()
-    if settings.LLM_SPECIALIST_MODEL:
-        p.model = settings.LLM_SPECIALIST_MODEL
-    return p
+async def _agent_provider(agent_id: str, *, tier: str) -> LLMProvider:
+    """构造某 agent 专属 provider。
 
-
-def _get_aggregator_provider() -> LLMProvider:
-    """终裁模型: LLM_AGGREGATOR_MODEL 回落 LLM_MODEL。"""
-    p = get_default_provider()
-    if settings.LLM_AGGREGATOR_MODEL:
-        p.model = settings.LLM_AGGREGATOR_MODEL
+    覆盖优先级:
+      模型: AGENT_MODEL_{ID}(运行时) → 层级默认(LLM_SPECIALIST/AGGREGATOR_MODEL) → 全局 LLM_MODEL
+      地址/密钥: AGENT_BASE_URL_{ID} / AGENT_API_KEY_{ID}(运行时) → 全局 LLM_BASE_URL / LLM_API_KEY
+    """
+    pfx = f"AGENT_{agent_id.upper()}_"
+    p = await get_default_provider()
+    tier_model = settings.LLM_SPECIALIST_MODEL if tier == "specialist" else settings.LLM_AGGREGATOR_MODEL
+    if tier_model:
+        p.model = tier_model
+    model = await get_runtime_value(f"{pfx}MODEL")
+    if model:
+        p.model = model
+    base = await get_runtime_value(f"{pfx}BASE_URL")
+    if base:
+        p.base_url = base
+    key = await get_runtime_value(f"{pfx}API_KEY")
+    if key:
+        p.api_key = key
     return p
 
 
 async def run_specialists(
     header: MatchHeader,
     *,
-    provider: LLMProvider,
     version: str = "v1",
 ) -> list[AgentReport]:
     """并行执行 5 个专家 agent。fail-open: 单个失败不影响其他。"""
     tasks = [
-        _run_one(spec, header, provider, version=version)
+        _run_one(spec, header, await _agent_provider(spec.name, tier="specialist"), version=version)
         for spec in SPECIALIST_SPECS
     ]
     results = await asyncio.gather(*tasks, return_exceptions=True)
@@ -125,7 +149,13 @@ async def _run_one(spec, header, provider, *, version) -> AgentReport:
 
 
 def _reports_to_json(reports: list[AgentReport]) -> str:
-    return json.dumps([r.to_dict() for r in reports], ensure_ascii=False, indent=1)
+    """报告序列化: agent 字段直接用中文专家全名,引导终裁用统一称呼引用。"""
+    out = []
+    for r in reports:
+        d = r.to_dict()
+        d["agent"] = AGENT_LABELS_ZH.get(d.get("agent", ""), d.get("agent"))
+        out.append(d)
+    return json.dumps(out, ensure_ascii=False, indent=1)
 
 
 async def run_aggregator(
@@ -147,7 +177,7 @@ async def run_aggregator(
         user=user_prompt,
         json_mode=True,
         temperature=0.2,
-        max_tokens=1000,
+        max_tokens=4096,  # 推理模型需要更大余量
     )
     if resp.error:
         raise RuntimeError(f"aggregator LLM error: {resp.error}")
@@ -171,12 +201,11 @@ async def predict_match_multi(
     prediction_cutoff_at = header.match_dt  # 默认:比赛时间作为数据截止
     now = datetime.now(timezone.utc)
 
-    # 2. 并行专家
-    specialist_provider = _get_specialist_provider()
-    reports = await run_specialists(header, provider=specialist_provider, version=version)
+    # 2. 并行专家(各自独立配置)
+    reports = await run_specialists(header, version=version)
 
     # 3. 终裁
-    aggregator_provider = _get_aggregator_provider()
+    aggregator_provider = await _agent_provider("aggregator", tier="aggregator")
     final, agg_prompt_tokens, agg_completion_tokens = await run_aggregator(
         header, reports, provider=aggregator_provider, version=version
     )
@@ -203,30 +232,33 @@ async def predict_match_multi(
 
         # agent_weights 同样必须过校验(旧实现直接取 raw 值落库,未做任何检查)
         agent_weights = validate_agent_weights(final.get("agent_weights"))
-        pred = Prediction(
+        pred = await _upsert_prediction(
+            session,
             match_id=match_id,
-            provider=settings.LLM_PROVIDER,
+            provider_name=settings.LLM_PROVIDER,
             model=aggregator_provider.model,
-            prompt_version=f"multi_{version}",
             mode="multi",
-            prompt_tokens=sum(r.prompt_tokens or 0 for r in reports) + agg_prompt_tokens,
-            completion_tokens=sum(r.completion_tokens or 0 for r in reports) + agg_completion_tokens,
-            latency_ms=latency_ms,
-            pred_home_goals=validated.pred_home_goals,
-            pred_away_goals=validated.pred_away_goals,
-            pred_1x2=validated.pred_1x2,
-            subjective_confidence=validated.subjective_confidence,
-            reasoning=validated.reasoning,
-            raw_response=final,
-            agent_outputs=[r.to_dict() for r in reports],
-            status="success",
-            match_kickoff_at=match_kickoff_at,
-            prediction_cutoff_at=prediction_cutoff_at,
-            prediction_created_at=now,
-            input_hash=input_hash,
+            values={
+                "prompt_version": f"multi_{version}",
+                "prompt_tokens": sum(r.prompt_tokens or 0 for r in reports) + agg_prompt_tokens,
+                "completion_tokens": sum(r.completion_tokens or 0 for r in reports) + agg_completion_tokens,
+                "latency_ms": latency_ms,
+                "pred_home_goals": validated.pred_home_goals,
+                "pred_away_goals": validated.pred_away_goals,
+                "alt_pred_home_goals": validated.alt_pred_home_goals,
+                "alt_pred_away_goals": validated.alt_pred_away_goals,
+                "pred_1x2": validated.pred_1x2,
+                "subjective_confidence": validated.subjective_confidence,
+                "reasoning": validated.reasoning,
+                "raw_response": final,
+                "agent_outputs": [r.to_dict() for r in reports],
+                "status": "success",
+                "match_kickoff_at": match_kickoff_at,
+                "prediction_cutoff_at": prediction_cutoff_at,
+                "prediction_created_at": now,
+                "input_hash": input_hash,
+            },
         )
-        session.add(pred)
-        await session.refresh(pred)
 
         return MultiPredictResult(
             prediction_id=pred.id,
@@ -236,6 +268,8 @@ async def predict_match_multi(
             mode="multi",
             pred_home_goals=pred.pred_home_goals,
             pred_away_goals=pred.pred_away_goals,
+            alt_pred_home_goals=pred.alt_pred_home_goals,
+            alt_pred_away_goals=pred.alt_pred_away_goals,
             pred_1x2=pred.pred_1x2,
             subjective_confidence=pred.subjective_confidence,
             reasoning=pred.reasoning,