"""Create recovery_planner
Generated by Phi-Octopus Eden
2025-11-08 07:28:35.241101
"""

```python
from typing import Dict, Any


class RecoveryPlanner:
    """
    A class designed to handle limited error recovery by planning a sequence of actions based on encountered errors.
    
    Attributes:
        actions: A dictionary mapping error codes to recovery action plans.
        current_plan: The current recovery plan being executed or None if no plan is active.
        
    Methods:
        add_recovery_action: Adds an action plan for a given error code.
        start_recovery: Starts the recovery process by executing the first step of the plan for the encountered error.
        continue_recovery: Continues the recovery process based on the current state and actions defined in the plans.
    """
    
    def __init__(self):
        self.actions: Dict[str, Any] = {}
        self.current_plan = None
    
    def add_recovery_action(self, error_code: str, action: Any) -> None:
        """Add a recovery action plan for a given error code."""
        if error_code not in self.actions:
            self.actions[error_code] = []
        self.actions[error_code].append(action)
    
    def start_recovery(self, error_code: str) -> None:
        """Starts the recovery process for an encountered error."""
        if error_code in self.actions:
            self.current_plan = self.actions[error_code]
            print(f"Starting recovery plan for {error_code}")
        else:
            print(f"No recovery plan found for {error_code}")
    
    def continue_recovery(self) -> None:
        """Continues the current recovery process."""
        if self.current_plan and len(self.current_plan) > 0:
            action = self.current_plan.pop(0)
            if callable(action):
                try:
                    result = action()
                    print(f"Action executed: {result}")
                except Exception as e:
                    print(f"Action failed with error: {e}")
            else:
                print("Non-callable action detected")
        else:
            print("No active recovery plan or it has been completed.")
            self.current_plan = None


# Example usage

def handle_network_error() -> str:
    """Example callable action for network errors."""
    print("Network error handled, trying to reconnect...")
    return "Reconnection attempt successful"

def handle_database_error() -> str:
    """Example callable action for database errors."""
    print("Database error encountered, retrying operation...")
    return "Operation retried successfully"


# Create an instance of RecoveryPlanner
recovery_planner = RecoveryPlanner()

# Add actions to the recovery planner
recovery_planner.add_recovery_action('NETWORK_ERROR', handle_network_error)
recovery_planner.add_recovery_action('DATABASE_ERROR', handle_database_error)

# Start a recovery plan for a specific error
recovery_planner.start_recovery('NETWORK_ERROR')

# Continue with the recovery process
recovery_planner.continue_recovery()

print("\nStarting another recovery plan...")
recovery_planner.start_recovery('DATABASE_ERROR')
recovery_planner.continue_recovery()
```