healer := sdk.NewSelfHealingAgent(
    agent,
    sdk.SelfHealingConfig{
        MaxRetries:      3,
        AutoRecover:     true,
        EnableLearning:  true,
    },
    logger,
    metrics,
)

response, err := healer.Process(ctx, "Your prompt")
// Automatically retries with smart strategies on failure

type CustomStrategy struct{}

func (s *CustomStrategy) Name() string {
    return "custom"
}

func (s *CustomStrategy) Recover(
    ctx context.Context,
    agent *sdk.Agent,
    input string,
    originalError error,
) (*sdk.Result, error) {
    // Your custom recovery logic
    
    // Example: Add context and retry
    enhanced := fmt.Sprintf("Context: %s\n\n%s", getContext(), input)
    return agent.Execute(ctx, enhanced)
}

func (s *CustomStrategy) ShouldApply(err error) bool {
    // When should this strategy be used?
    return errors.Is(err, sdk.ErrInvalidResponse)
}

// Register
healer.RegisterStrategy("custom", &CustomStrategy{})

healer := sdk.NewSelfHealingAgent(agent, 
    sdk.SelfHealingConfig{
        EnableLearning: true,  // Enable ML-based learning
        MaxRetries:     3,
    },
    logger, metrics,
)

// After multiple recoveries, the agent learns:
// - Which errors are most common
// - Which strategies work best
// - When to switch strategies automatically

stats := healer.GetRecoveryStats()
fmt.Printf("Total recoveries: %d\n", stats.TotalAttempts)
fmt.Printf("Success rate: %.2f%%\n", stats.SuccessRate * 100)
fmt.Printf("Most effective strategy: %s\n", stats.MostEffectiveStrategy)

stats := healer.GetRecoveryStats()

fmt.Printf("Attempts: %d\n", stats.TotalAttempts)
fmt.Printf("Successes: %d\n", stats.SuccessfulRecoveries)
fmt.Printf("Success Rate: %.2f%%\n", stats.SuccessRate * 100)
fmt.Printf("Average Retries: %.1f\n", stats.AverageRetries)

// Strategy effectiveness
for strategy, count := range stats.StrategyUsage {
    successRate := stats.StrategySuccess[strategy] / float64(count) * 100
    fmt.Printf("%s: %.1f%% success (%d uses)\n", 
        strategy, successRate, count)
}

patterns := healer.GetErrorPatterns()

for _, pattern := range patterns {
    fmt.Printf("Error: %s\n", pattern.ErrorType)
    fmt.Printf("Count: %d\n", pattern.Count)
    fmt.Printf("Best Strategy: %s (%.1f%% success)\n",
        pattern.BestStrategy, pattern.SuccessRate * 100)
}

func createRobustAgent() *sdk.SelfHealingAgent {
    // Base agent
    agent := sdk.NewAgent("robust", llm, logger, metrics, 
        &sdk.AgentOptions{
            Model: "gpt-4",
        },
    )
    
    // Self-healing wrapper
    healer := sdk.NewSelfHealingAgent(agent,
        sdk.SelfHealingConfig{
            MaxRetries:      5,
            AutoRecover:     true,
            EnableLearning:  true,
            InitialDelay:    1 * time.Second,
        },
        logger, metrics,
    )
    
    // Register strategies
    healer.RegisterStrategy("fallback", &sdk.FallbackModelStrategy{
        FallbackModel: "gpt-3.5-turbo",
    })
    
    healer.RegisterStrategy("rephrase", &sdk.RephraseStrategy{
        RephrasePrompt: "Rephrase for clarity: ",
    })
    
    healer.RegisterStrategy("tool", &sdk.ToolUseStrategy{
        ToolName: "search_context",
    })
    
    return healer
}

// Use
healer := createRobustAgent()

response, err := healer.Process(ctx, "Complex query")
if err != nil {
    // All strategies failed
    log.Printf("Recovery failed: %v", err)
    
    // Check what was tried
    stats := healer.GetRecoveryStats()
    log.Printf("Attempted %d recoveries", stats.TotalAttempts)
}

type SelfHealingConfig struct {
    // Maximum recovery attempts
    MaxRetries int
    
    // Enable automatic recovery
    AutoRecover bool
    
    // Enable ML-based learning
    EnableLearning bool
    
    // Initial delay before retry
    InitialDelay time.Duration
    
    // Maximum delay between retries
    MaxDelay time.Duration
    
    // Backoff multiplier
    BackoffMultiplier float64
    
    // Maximum error history to keep
    MaxErrorHistory int
    
    // Strategy selection threshold
    // (confidence needed to auto-switch)
    StrategyThreshold float64
}

// Enable detailed logging
healer.SetVerbose(true)

response, err := healer.Process(ctx, input)

// Check error history
for _, errEntry := range healer.GetErrorHistory() {
    log.Printf("Error: %v", errEntry.Error)
    log.Printf("Strategy used: %s", errEntry.StrategyUsed)
    log.Printf("Recovered: %v", errEntry.Recovered)
    log.Printf("Time: %s", errEntry.Timestamp)
}