| from __future__ import annotations |
|
|
| from dataclasses import dataclass |
| from typing import Any |
|
|
| import numpy as np |
|
|
| from solarchain_eval.actions import encode_actual_action |
| from solarchain_eval.config import BenchmarkConfig |
|
|
| from .auditor import LLMAuditor, NoOpAuditor, RuleAuditor, build_audit_context, hard_safety_triggered |
| from .context import build_episode_context |
| from .planner import LLMPlanner, RulePlanner, SafeDefaultPlanner |
| from .schemas import PlannerOutput, action_dict, action_values_to_array, apply_plan_bounds |
|
|
|
|
| @dataclass |
| class AgenticConfig: |
| agentic_mode: str = "none" |
| planner: str = "none" |
| auditor: str = "none" |
| audit_trigger: str = "event" |
| save_agentic_logs: bool = False |
|
|
|
|
| class AgenticActionProcessor: |
| def __init__( |
| self, |
| *, |
| config: BenchmarkConfig, |
| planner: SafeDefaultPlanner | RulePlanner | LLMPlanner, |
| auditor: NoOpAuditor | RuleAuditor | LLMAuditor, |
| agentic_config: AgenticConfig, |
| ) -> None: |
| self.config = config |
| self.planner = planner |
| self.auditor = auditor |
| self.agentic_config = agentic_config |
| self.current_plan: PlannerOutput | None = None |
| self.stats = { |
| "plan_count": 0, |
| "plan_valid_count": 0, |
| "audit_call_count": 0, |
| "revision_count": 0, |
| "action_modification_count": 0, |
| "action_delta_sum": 0.0, |
| "llm_failure_count": 0, |
| "audit_budget_per_episode": 0, |
| "target_audit_rate": 0.0, |
| "audit_cooldown_steps": 0, |
| } |
| self._planner_failure_seen = 0 |
| self._auditor_failure_seen = 0 |
| self._step_index = 0 |
| self._episode_audit_count = 0 |
| self._last_audit_step = -10_000 |
|
|
| def reset(self, env: Any) -> PlannerOutput: |
| episode_context = build_episode_context(env) |
| self.current_plan = self.planner.plan(episode_context) |
| target_budget = int(round(float(self.current_plan.audit_policy.target_audit_rate) * float(self.config.episode_steps))) |
| self.current_plan.audit_policy.max_audits_per_episode = int( |
| np.clip( |
| min(self.current_plan.audit_policy.max_audits_per_episode, max(target_budget, 1)), |
| 1, |
| self.config.episode_steps, |
| ) |
| ) |
| self.stats["audit_budget_per_episode"] = int(self.current_plan.audit_policy.max_audits_per_episode) |
| self.stats["target_audit_rate"] = float(self.current_plan.audit_policy.target_audit_rate) |
| self.stats["audit_cooldown_steps"] = int(self.current_plan.audit_policy.audit_cooldown_steps) |
| self.stats["plan_count"] += 1 |
| if getattr(self.planner, "last_valid", True): |
| self.stats["plan_valid_count"] += 1 |
| planner_failures = int(getattr(self.planner, "failure_count", 0)) |
| self.stats["llm_failure_count"] += max(planner_failures - self._planner_failure_seen, 0) |
| self._planner_failure_seen = planner_failures |
| self._step_index = 0 |
| self._episode_audit_count = 0 |
| self._last_audit_step = -10_000 |
| return self.current_plan |
|
|
| def process( |
| self, |
| *, |
| obs: np.ndarray, |
| proposed_actual_action: np.ndarray, |
| previous_action: np.ndarray, |
| latest_info: dict[str, Any] | None = None, |
| ) -> tuple[np.ndarray, dict[str, Any], dict[str, Any]]: |
| if self.current_plan is None: |
| raise RuntimeError("AgenticActionProcessor.reset() must be called before process().") |
|
|
| original = np.asarray(proposed_actual_action, dtype=np.float32) |
| bounded = apply_plan_bounds(original, self.current_plan, self.config) |
| audit_called = False |
| audit_decision = "not_called" |
| audit_reason = "Audit trigger not reached." |
| audit_payload: dict[str, Any] | None = None |
| final = bounded |
|
|
| should_audit, audit_skip_reason = self._should_call_auditor(obs, bounded, previous_action) |
| if self.agentic_config.agentic_mode == "planner_auditor" and should_audit: |
| audit_called = True |
| step_context = build_audit_context(obs, bounded, previous_action, self.current_plan, latest_info) |
| audit = self.auditor.audit(step_context) |
| audit_payload = audit.model_dump() |
| audit_decision = audit.decision |
| audit_reason = audit.reason |
| self.stats["audit_call_count"] += 1 |
| self._episode_audit_count += 1 |
| if audit.decision == "revise": |
| final = action_values_to_array(audit.final_action) |
| self.stats["revision_count"] += 1 |
| self._last_audit_step = self._step_index |
| elif self.agentic_config.agentic_mode == "planner_auditor": |
| audit_reason = audit_skip_reason |
|
|
| delta = float(np.linalg.norm(final - original, ord=1)) |
| modified = bool(delta > 1e-6) |
| if modified: |
| self.stats["action_modification_count"] += 1 |
| self.stats["action_delta_sum"] += delta |
| auditor_failures = int(getattr(self.auditor, "failure_count", 0)) |
| self.stats["llm_failure_count"] += max(auditor_failures - self._auditor_failure_seen, 0) |
| self._auditor_failure_seen = auditor_failures |
|
|
| info = { |
| "llm_plan": self.current_plan.model_dump(), |
| "llm_audit": audit_payload, |
| "agentic_action_modified": modified, |
| "agentic_original_action": action_dict(original), |
| "agentic_final_action": action_dict(final), |
| } |
| log_row = { |
| "plan": self.current_plan.model_dump(), |
| "audit_called": audit_called, |
| "audit_decision": audit_decision, |
| "original_action": action_dict(original), |
| "final_action": action_dict(final), |
| "action_modified": modified, |
| "action_delta": delta, |
| "reason": audit_reason, |
| "audit_budget_used": int(self._episode_audit_count), |
| "audit_budget_limit": int(self.current_plan.audit_policy.max_audits_per_episode), |
| "audit_cooldown_steps": int(self.current_plan.audit_policy.audit_cooldown_steps), |
| } |
| self._step_index += 1 |
| return encode_actual_action(final, self.config), info, log_row |
|
|
| def _should_call_auditor( |
| self, |
| obs: np.ndarray, |
| bounded_action: np.ndarray, |
| previous_action: np.ndarray, |
| ) -> tuple[bool, str]: |
| if self.current_plan is None: |
| return False, "No planner policy available." |
| if self.agentic_config.agentic_mode != "planner_auditor": |
| return False, "Auditor disabled." |
| if self.agentic_config.audit_trigger == "always": |
| triggered = True |
| else: |
| triggered = self.auditor.should_audit(obs, bounded_action, previous_action, self.current_plan) |
| if not triggered: |
| return False, "Audit trigger not reached." |
|
|
| hard_trigger = hard_safety_triggered(obs, self.current_plan) |
| budget = int(self.current_plan.audit_policy.max_audits_per_episode) |
| if self._episode_audit_count >= budget and not hard_trigger: |
| return False, f"Audit budget exhausted ({budget} per episode)." |
|
|
| cooldown = int(self.current_plan.audit_policy.audit_cooldown_steps) |
| if ( |
| cooldown > 0 |
| and self._step_index - self._last_audit_step <= cooldown |
| and not hard_trigger |
| ): |
| return False, f"Audit cooldown active ({cooldown} steps)." |
|
|
| return True, "Audit trigger reached." |
|
|
|
|
| def make_agentic_processor( |
| *, |
| config: BenchmarkConfig, |
| agentic_config: AgenticConfig, |
| llm_client: Any, |
| ) -> AgenticActionProcessor: |
| if agentic_config.planner == "rule": |
| planner = RulePlanner(config) |
| elif agentic_config.planner == "llm": |
| planner = LLMPlanner(llm_client, config) |
| else: |
| planner = SafeDefaultPlanner(config) |
|
|
| if agentic_config.auditor == "rule": |
| auditor = RuleAuditor(config, agentic_config.audit_trigger) |
| elif agentic_config.auditor == "llm": |
| auditor = LLMAuditor(llm_client, config, agentic_config.audit_trigger) |
| else: |
| auditor = NoOpAuditor(config, agentic_config.audit_trigger) |
|
|
| processor = AgenticActionProcessor( |
| config=config, |
| planner=planner, |
| auditor=auditor, |
| agentic_config=agentic_config, |
| ) |
| return processor |
|
|
|
|
| def agentic_metrics(stats: dict[str, Any], step_count: int) -> dict[str, Any]: |
| plan_count = int(stats.get("plan_count", 0)) |
| audit_count = int(stats.get("audit_call_count", 0)) |
| revision_count = int(stats.get("revision_count", 0)) |
| modification_count = int(stats.get("action_modification_count", 0)) |
| return { |
| "plan_validity_rate": float(stats.get("plan_valid_count", 0) / max(plan_count, 1)), |
| "audit_call_rate": float(audit_count / max(step_count, 1)), |
| "revision_rate": float(revision_count / max(audit_count, 1)), |
| "action_modification_rate": float(modification_count / max(step_count, 1)), |
| "avg_action_delta_from_auditor": float(stats.get("action_delta_sum", 0.0) / max(step_count, 1)), |
| "llm_failure_count": int(stats.get("llm_failure_count", 0)), |
| "audit_budget_per_episode": int(stats.get("audit_budget_per_episode", 0)), |
| "target_audit_rate": float(stats.get("target_audit_rate", 0.0)), |
| "audit_cooldown_steps": int(stats.get("audit_cooldown_steps", 0)), |
| } |
|
|
