| from __future__ import annotations |
|
|
| import json |
| import sys |
| from pathlib import Path |
|
|
| import numpy as np |
| import pytest |
|
|
| ROOT = Path(__file__).resolve().parents[1] |
| sys.path.insert(0, str(ROOT / "src")) |
|
|
| from solarchain_eval.agent.auditor import LLMAuditor, RuleAuditor |
| from solarchain_eval.agent.context import build_step_context |
| from solarchain_eval.agent.llm_client import make_llm_client |
| from solarchain_eval.agent.planner import LLMPlanner, RulePlanner |
| from solarchain_eval.agent.schemas import ( |
| ActionBounds, |
| ActionValues, |
| AuditPolicy, |
| AuditorOutput, |
| PlannerOutput, |
| RiskAssessment, |
| action_values_to_array, |
| validate_auditor_output, |
| validate_planner_output, |
| ) |
| from solarchain_eval.agent.wrappers import AgenticActionProcessor, AgenticConfig |
| from solarchain_eval.config import load_config |
| from solarchain_eval.evaluate import evaluate_policies |
| from solarchain_eval.policies import make_builtin_policy |
|
|
|
|
| def test_planner_schema_validation_and_clipping(): |
| config = load_config() |
| raw = PlannerOutput( |
| governance_mode="test", |
| action_bounds=ActionBounds( |
| reward_ratio=[-1.0, 2.0], |
| liquidity_ratio=[2.0, -1.0], |
| burn_rate=[-1.0, 1.0], |
| ), |
| audit_policy=AuditPolicy( |
| force_audit_if_violation_rate_above=2.0, |
| force_audit_if_gap_below=10.0, |
| force_audit_if_action_jitter_above=9.0, |
| force_audit_if_static_slippage_above=99.0, |
| max_audits_per_episode=99, |
| target_audit_rate=1.0, |
| audit_cooldown_steps=99, |
| ), |
| rationale="clip me", |
| ) |
| plan, valid, error = validate_planner_output(raw, config) |
|
|
| assert valid, error |
| assert plan.action_bounds.reward_ratio == [config.market.min_reward_ratio, config.market.max_reward_ratio] |
| assert plan.action_bounds.burn_rate == [0.0, config.market.max_burn_rate] |
| assert plan.audit_policy.force_audit_if_violation_rate_above == 1.0 |
| assert plan.audit_policy.force_audit_if_gap_below == 0.0 |
| assert plan.audit_policy.max_audits_per_episode == config.episode_steps |
| assert plan.audit_policy.audit_cooldown_steps == config.episode_steps |
|
|
|
|
| def test_auditor_schema_validation_and_action_sanitization(): |
| config = load_config() |
| raw = AuditorOutput( |
| decision="revise", |
| final_action=ActionValues(reward_ratio=1.0, liquidity_ratio=1.0, burn_rate=1.0), |
| risk_assessment=RiskAssessment( |
| physics_risk="high", |
| liquidity_risk="high", |
| jitter_risk="high", |
| fairness_risk="unknown", |
| ), |
| reason="sanitize me", |
| ) |
| audit, valid, error = validate_auditor_output(raw, config, np.array([0.2, 0.7, 0.02], dtype=np.float32)) |
| final = action_values_to_array(audit.final_action) |
|
|
| assert valid, error |
| assert final[0] + final[1] <= config.market.max_total_allocation + 1e-6 |
| assert final[2] <= config.market.max_burn_rate |
|
|
|
|
| class FakeStructuredClient: |
| def plan_structured(self, messages): |
| return PlannerOutput( |
| governance_mode="fake_api", |
| action_bounds=ActionBounds( |
| reward_ratio=[0.08, 0.50], |
| liquidity_ratio=[0.30, 0.85], |
| burn_rate=[0.0, 0.16], |
| ), |
| audit_policy=AuditPolicy( |
| force_audit_if_violation_rate_above=0.01, |
| force_audit_if_gap_below=-0.10, |
| force_audit_if_action_jitter_above=0.25, |
| force_audit_if_static_slippage_above=0.75, |
| max_audits_per_episode=6, |
| target_audit_rate=0.25, |
| audit_cooldown_steps=2, |
| ), |
| rationale="Fake structured API plan for tests.", |
| ) |
|
|
| def audit_structured(self, messages): |
| return AuditorOutput( |
| decision="approve", |
| final_action=ActionValues(reward_ratio=0.25, liquidity_ratio=0.75, burn_rate=0.02), |
| risk_assessment=RiskAssessment( |
| physics_risk="low", |
| liquidity_risk="low", |
| jitter_risk="low", |
| fairness_risk="low", |
| ), |
| reason="Fake structured API audit approves.", |
| ) |
|
|
|
|
| def test_fake_structured_client_returns_schema_outputs(): |
| client = FakeStructuredClient() |
| plan = client.plan_structured([]) |
| audit = client.audit_structured([]) |
|
|
| assert isinstance(plan, PlannerOutput) |
| assert isinstance(audit, AuditorOutput) |
| assert audit.decision in {"approve", "revise"} |
|
|
|
|
| def test_make_llm_client_requires_key_and_model(monkeypatch): |
| monkeypatch.delenv("SOLARCHAIN_LLM_API_KEY", raising=False) |
| monkeypatch.delenv("OPENAI_API_KEY", raising=False) |
| monkeypatch.delenv("SOLARCHAIN_LLM_MODEL", raising=False) |
| monkeypatch.delenv("OPENAI_MODEL", raising=False) |
|
|
| with pytest.raises(RuntimeError, match="API key is required"): |
| make_llm_client() |
|
|
|
|
| def test_llm_errors_propagate_without_safe_fallback(): |
| class FailingClient: |
| def plan_structured(self, messages): |
| raise RuntimeError("planner failed") |
|
|
| def audit_structured(self, messages): |
| raise RuntimeError("auditor failed") |
|
|
| config = load_config() |
| planner = LLMPlanner(FailingClient(), config) |
| with pytest.raises(RuntimeError, match="planner failed"): |
| planner.plan({}) |
|
|
| plan = RulePlanner(config).plan({}) |
| auditor = LLMAuditor(FailingClient(), config) |
| step_context = build_step_context( |
| np.zeros(12, dtype=np.float32), |
| np.array([0.25, 0.75, 0.02], dtype=np.float32), |
| np.array([0.25, 0.75, 0.02], dtype=np.float32), |
| plan, |
| ) |
| with pytest.raises(RuntimeError, match="auditor failed"): |
| auditor.audit(step_context) |
|
|
|
|
| def test_rule_agentic_eval_smoke(tmp_path): |
| config = load_config() |
| config.episode_steps = 3 |
| policy = make_builtin_policy("static", config) |
| agentic_config = AgenticConfig( |
| agentic_mode="planner_auditor", |
| planner="rule", |
| auditor="rule", |
| audit_trigger="event", |
| save_agentic_logs=True, |
| ) |
|
|
| metrics, actions, _ = evaluate_policies([policy], config, 1, tmp_path, agentic_config=agentic_config) |
|
|
| assert "plan_validity_rate" in metrics.columns |
| assert "agentic_action_modified" in actions.columns |
| log_path = tmp_path / "agentic_logs.jsonl" |
| assert log_path.exists() |
| assert json.loads(log_path.read_text(encoding="utf-8").splitlines()[0])["policy"] == "static" |
|
|
|
|
| def test_event_auditor_budget_cooldown_and_hard_trigger_bypass(): |
| config = load_config() |
| config.episode_steps = 24 |
| agentic_config = AgenticConfig(agentic_mode="planner_auditor", planner="rule", auditor="rule", audit_trigger="event") |
| processor = AgenticActionProcessor( |
| config=config, |
| planner=RulePlanner(config), |
| auditor=RuleAuditor(config), |
| agentic_config=agentic_config, |
| ) |
| processor.current_plan = RulePlanner(config).plan({}) |
| processor.current_plan.audit_policy.max_audits_per_episode = 2 |
| processor.current_plan.audit_policy.audit_cooldown_steps = 2 |
|
|
| obs = np.zeros(12, dtype=np.float32) |
| action = np.array([0.40, 0.45, 0.08], dtype=np.float32) |
| previous = np.zeros(3, dtype=np.float32) |
|
|
| _, _, first_log = processor.process(obs=obs, proposed_actual_action=action, previous_action=previous) |
| _, _, second_log = processor.process(obs=obs, proposed_actual_action=action, previous_action=previous) |
|
|
| assert first_log["audit_called"] |
| assert not second_log["audit_called"] |
| assert "cooldown" in second_log["reason"] |
|
|
| processor._episode_audit_count = processor.current_plan.audit_policy.max_audits_per_episode |
| hard_obs = obs.copy() |
| hard_obs[5] = -0.25 |
| _, _, hard_log = processor.process(obs=hard_obs, proposed_actual_action=action, previous_action=previous) |
|
|
| assert hard_log["audit_called"] |
|
|
|
|
| def test_agentic_eval_with_no_physics_penalty(tmp_path): |
| config = load_config() |
| config.episode_steps = 2 |
| config.no_physics_penalty = True |
| policy = make_builtin_policy("myopic", config) |
| agentic_config = AgenticConfig(agentic_mode="planner", planner="rule") |
|
|
| metrics, _, _ = evaluate_policies([policy], config, 1, tmp_path, agentic_config=agentic_config) |
|
|
| assert bool(config.no_physics_penalty) |
| assert float(metrics["plan_validity_rate"].iloc[0]) == 1.0 |
|
|
