"""Create recovery_planner
Generated by Phi-Octopus Eden
2025-11-06 07:20:39.820212
"""

```python
from typing import Dict, Any


class RecoveryPlanner:
    """
    A class for creating a recovery planner that handles limited error scenarios.
    """

    def __init__(self):
        self.recovery_strategies: Dict[str, Any] = {}

    def add_recovery_strategy(self, error_type: str, strategy_func: callable) -> None:
        """
        Add a recovery strategy to the planner.

        :param error_type: The type of error this strategy handles.
        :param strategy_func: A function that takes an exception and returns a recovery action.
        """
        self.recovery_strategies[error_type] = strategy_func

    def handle_error(self, error_type: str, exc_info) -> Any:
        """
        Handle the given error using the appropriate recovery strategy.

        :param error_type: The type of error that occurred.
        :param exc_info: Information about the exception to be handled.
        :return: The result of applying the recovery strategy or None if no strategy is found.
        """
        if error_type in self.recovery_strategies:
            return self.recovery_strategies[error_type](exc_info)
        else:
            print(f"No recovery strategy for {error_type}")
            return None


# Example usage
def recover_from_value_error(exc_info: Any) -> str:
    """Recover from ValueError by returning a default value."""
    _, error, _ = exc_info
    if isinstance(error, ValueError):
        return "Using default value"
    else:
        raise error  # Re-raise the exception if it's not a ValueError


def recover_from_key_error(exc_info: Any) -> str:
    """Recover from KeyError by returning an empty string."""
    _, error, _ = exc_info
    if isinstance(error, KeyError):
        return ""
    else:
        raise error  # Re-raise the exception if it's not a KeyError


# Create an instance of RecoveryPlanner and add recovery strategies
recovery_planner = RecoveryPlanner()
recovery_planner.add_recovery_strategy("ValueError", recover_from_value_error)
recovery_planner.add_recovery_strategy("KeyError", recover_from_key_error)

# Simulate errors and handle them using the planner
try:
    # This should trigger a KeyError in recovery_planner.handle_error due to an intentionally non-existent key
    print(recovery_planner.handle_error("KeyError", {"key": "value"}))
except Exception as e:
    print(f"An unexpected error occurred: {e}")

# This should not trigger any errors, and thus no recovery strategy will be called
try:
    value = int("not a number")  # Raises ValueError
    print(recovery_planner.handle_error("ValueError", (None, ValueError(), None)))
except Exception as e:
    print(f"An unexpected error occurred: {e}")
```