reset_safeguard_policy

def reset_safeguard_policy(
    *,
    agents: list[ConversableAgent] | None = None,
    groupchat_manager: GroupChatManager | None = None,
) -> None:
    """Reset/remove all safeguards from agents and groupchat managers.

    This function removes all safeguard hooks and inter-agent guardrails that were
    previously applied by apply_safeguard_policy. Events are sent to track the reset process.

    Args:
        agents: List of agents to remove safeguards from (optional if groupchat_manager provided)
        groupchat_manager: GroupChatManager to remove safeguards from (optional if agents provided)

    Example:
        ```python
        from autogen.agentchat.group.safeguards import reset_safeguard_policy

        # Remove safeguards from agents
        reset_safeguard_policy(agents=[agent1, agent2, agent3])

        # Or remove from GroupChatManager
        reset_safeguard_policy(groupchat_manager=manager)
        ```
    """
    from ....events.print_event import PrintEvent
    from ....io.base import IOStream

    iostream = IOStream.get_default()

    # Send initial reset event
    iostream.send(PrintEvent("Resetting safeguards..."))
    # Determine which agents to remove safeguards from
    target_agents: list[ConversableAgent | Agent] = []

    if groupchat_manager:
        if not isinstance(groupchat_manager, GroupChatManager):
            raise ValueError("groupchat_manager must be an instance of GroupChatManager")

        target_agents.extend([agent for agent in groupchat_manager.groupchat.agents if hasattr(agent, "hook_lists")])

        agent_names = [agent.name for agent in target_agents]
        iostream.send(PrintEvent(f"📋 Found {len(target_agents)} agents in GroupChat: {', '.join(agent_names)}"))

        # Clear inter-agent guardrails from the groupchat
        if hasattr(groupchat_manager.groupchat, "_inter_agent_guardrails"):
            guardrail_count = len(groupchat_manager.groupchat._inter_agent_guardrails)
            if guardrail_count > 0:
                iostream.send(PrintEvent(f"🔗 Clearing {guardrail_count} inter-agent guardrails from GroupChat"))
            groupchat_manager.groupchat._inter_agent_guardrails.clear()

    elif agents:
        target_agents.extend(agents)
        agent_names = [agent.name for agent in target_agents]
        iostream.send(PrintEvent(f"📋 Resetting safeguards for {len(target_agents)} agents: {', '.join(agent_names)}"))
    else:
        raise ValueError("Either agents or groupchat_manager must be provided")

    # Remove safeguard hooks from each agent
    safeguard_hook_names = [
        "safeguard_tool_inputs",
        "safeguard_tool_outputs",
        "safeguard_llm_inputs",
        "safeguard_llm_outputs",
        "safeguard_human_inputs",
        "process_message_before_send",  # Inter-agent communication hooks for direct agent communication
    ]

    for agent in target_agents:
        if hasattr(agent, "hook_lists"):
            # Use the agent's reset_safeguards method for agent-to-environment safeguards
            if hasattr(agent, "reset_safeguards"):
                agent.reset_safeguards()
            else:
                # Fallback to manual clearing for older agent versions
                for hook_name in safeguard_hook_names:
                    if hook_name in agent.hook_lists:
                        # Clear all hooks in safeguard-specific hook lists
                        agent.hook_lists[hook_name].clear()

            # Manually clear inter-agent safeguards (process_message_before_send)
            if "process_message_before_send" in agent.hook_lists:
                agent.hook_lists["process_message_before_send"].clear()
        else:
            raise ValueError(
                f"Agent {agent.name} does not support hooks. Please ensure it inherits from ConversableAgent."
            )

    # Send completion event
    iostream.send(PrintEvent(f"✅ Safeguard reset completed for {len(target_agents)} agents"))