import yaml

class Policy:
    def __init__(self, name, action, effect, condition=None):
        self.name = name
        self.action = action
        self.effect = effect
        self.condition = condition or {}

def load_policies(path: str):
    with open(path, "r") as f:
        data = yaml.safe_load(f)

    return [Policy(**p) for p in data["policies"]]

class ConstraintEngine:
    def __init__(self, policies):
        self.policies = policies

    def evaluate(self, action: str, metadata: dict):
        for policy in self.policies:
            if policy.action == action:
                return self._apply(policy, metadata)

        return {"status": "allow"}

    def _apply(self, policy, metadata):
        if policy.effect == "deny":
            return {"status": "blocked", "reason": policy.name}

        if policy.effect == "require_approval":
            return {"status": "pending_approval"}

        if policy.effect == "throttle":
            return {"status": "throttled"}

        return {"status": "allow"}

class ActionInterceptor:
    def __init__(self, constraint_engine):
        self.engine = constraint_engine

    def execute(self, action, payload):
        decision = self.engine.evaluate(action, payload)

        if decision["status"] == "blocked":
            raise Exception(f"Blocked by policy: {decision['reason']}")

        if decision["status"] == "pending_approval":
            return {"status": "waiting_human"}

        return self._execute_action(action, payload)

    def _execute_action(self, action, payload):
        # call actual tool here
        return {"status": "success", "data": payload}

class PlannerAgent:
    def plan(self, user_input: str):
        return {
            "tasks": [
                {"action": "read", "target": "knowledge_base"},
                {"action": "external_api", "target": "weather_api"}
            ]
        }

class ExecutorAgent:
    def __init__(self, interceptor):
        self.interceptor = interceptor

    def execute(self, plan):
        results = []

        for task in plan["tasks"]:
            result = self.interceptor.execute(
                action=task["action"],
                payload=task
            )
            results.append(result)

        return results

def run_agent_system(user_input):
    plan = planner.plan(user_input)
    result = executor.execute(plan)
    return result

def log_event(event_type, payload):
    print(f"[LOG] {event_type}: {payload}")