Self-Healing

// Agent implements exponential backoff automatically
const result = await agentbase.runAgent({
  message: "Scrape data from a website that may be temporarily down",
  mode: "base"
});

// Automatic retry pattern:
// Attempt 1: Immediate
// Attempt 2: Wait 1 second
// Attempt 3: Wait 2 seconds
// Attempt 4: Wait 4 seconds
// Attempt 5: Wait 8 seconds
// Total attempts: 5, then escalate to user

// Agent recognizes repeated failures and adapts strategy
const result = await agentbase.runAgent({
  message: "Process data using external API, fallback to local processing if API is down",
  mode: "base"
});

// Circuit breaker logic:
// 1. Try API: fails
// 2. Retry API: fails
// 3. Detect pattern of failures
// 4. Open circuit breaker (stop trying API)
// 5. Use fallback strategy (local processing)
// 6. Periodically test API recovery

// Agent delivers what it can despite errors
const result = await agentbase.runAgent({
  message: "Download and process data from 10 different sources",
  mode: "base"
});

// Graceful degradation:
// 1. Attempts all 10 sources
// 2. 2 sources fail (network timeout)
// 3. Processes 8 successful sources
// 4. Reports: "Processed 8/10 sources. Failed: source3, source7"
// 5. Delivers results from successful sources
// 6. Logs errors for failed sources

async function deploymentAutomation() {
  return await agentbase.runAgent({
    message: `
      Deploy application:
      1. Run tests
      2. Build Docker image
      3. Push to registry
      4. Deploy to production
      5. Run health checks

      If any step fails, diagnose and retry. If tests fail, show which tests failed.
    `,
    mode: "base"
  });

  // Self-healing handles:
  // - Flaky tests → rerun failed tests
  // - Docker build failures → clear cache and retry
  // - Registry push timeout → resume interrupted push
  // - Deployment rollout issues → rollback and retry
  // - Health check failures → wait for startup, retry checks
}

async function batchProcessing(fileList: string[]) {
  return await agentbase.runAgent({
    message: `
      Process ${fileList.length} files:
      - Convert each file from JSON to CSV
      - Validate data format
      - Upload to S3

      Track progress and handle errors gracefully.
      If a file fails, log it and continue with others.
    `,
    mode: "base"
  });

  // Self-healing ensures:
  // - Individual file failures don't stop entire job
  // - Progress is tracked and resumed if interrupted
  // - S3 upload retries on network issues
  // - Malformed files are logged and skipped
  // - Final report shows success/failure counts
}

async function weatherDataAggregation() {
  return await agentbase.runAgent({
    message: `
      Collect weather data from 5 different weather APIs.
      Aggregate the data and calculate average temperatures.
      Handle API failures gracefully - use data from available APIs.
    `,
    mode: "base",
    mcpServers: [
      { serverName: 'weather-api-1', serverUrl: 'https://api1.weather.com/mcp' },
      { serverName: 'weather-api-2', serverUrl: 'https://api2.weather.com/mcp' },
      // ... more APIs
    ]
  });

  // Self-healing provides:
  // - Parallel requests with timeout handling
  // - Retry failed APIs with backoff
  // - Calculate result from available APIs if some fail
  // - Report which APIs failed for monitoring
}

async function databaseMigration() {
  return await agentbase.runAgent({
    message: `
      Run database migration:
      1. Backup current database
      2. Run migration scripts
      3. Verify data integrity
      4. If anything fails, rollback to backup
    `,
    mode: "base"
  });

  // Self-healing handles:
  // - Connection timeouts → reconnect and retry
  // - Lock timeouts → wait and retry
  // - Constraint violations → rollback transaction
  // - Disk space issues → cleanup and retry
  // - Migration errors → automatic rollback
}

// Classify errors for appropriate handling
const result = await agentbase.runAgent({
  message: `
    Download and process files.

    Error types:

    RETRYABLE (use exponential backoff):
    - Network timeouts
    - Connection refused
    - 503 Service Unavailable
    - Rate limit (429)

    NON-RETRYABLE (fail fast):
    - 401 Unauthorized
    - 403 Forbidden
    - 404 Not Found
    - Invalid configuration

    RECOVERABLE (fix and retry):
    - Missing dependencies (install them)
    - Missing directories (create them)
    - File format errors (convert format)
  `,
  mode: "base"
});

// Implement circuit breaker pattern
const result = await agentbase.runAgent({
  message: `
    Call external API repeatedly.

    Circuit breaker rules:
    - If 5 consecutive failures occur, open circuit
    - When circuit is open, use fallback strategy (cached data)
    - Test circuit recovery every 60 seconds
    - Close circuit after 3 consecutive successes
  `,
  mode: "base"
});

// Track error recovery in traces
const result = await agentbase.runAgent({
  message: "Download data with automatic retry on failure",
  mode: "base",
  stream: true
});

const recoveryEvents = [];

for await (const event of result) {
  if (event.type === 'agent_error') {
    recoveryEvents.push({ type: 'error', error: event.error });
  }
  if (event.type === 'agent_thinking' && event.content.includes('retry')) {
    recoveryEvents.push({ type: 'recovery', thinking: event.content });
  }
}

console.log('Recovery events:', recoveryEvents);

// Hook into recovery process
const result = await agentbase.runAgent({
  message: "Process data with error recovery",
  mode: "base",
  hooks: {
    onError: async (error) => {
      // Log to external system
      await logger.error('Agent error detected', { error });
    },
    onRetry: async (attempt) => {
      // Track retry metrics
      await metrics.increment('agent.retry', { attempt });
    }
  }
});

// Eval for error recovery
describe('Self-Healing', () => {
  it('should recover from network errors', async () => {
    // Simulate flaky network
    const result = await agentbase.runAgent({
      message: "Download data from unreliable API",
      mode: "base"
    });

    // Verify recovery succeeded
    expect(result.success).toBe(true);
    expect(result.content).toContain('data downloaded');
  });

  it('should handle rate limits gracefully', async () => {
    const result = await agentbase.runAgent({
      message: "Make 1000 API requests",
      mode: "base"
    });

    // Should succeed despite rate limits
    expect(result.success).toBe(true);
  });
});

// Minimize recovery time
const result = await agentbase.runAgent({
  message: `
    Download data with optimized retry:
    - First retry: immediate
    - Second retry: 1 second wait
    - Third retry: 2 second wait
    - Max retries: 3
    - After 3 failures, use cached data if available
  `,
  mode: "base"
});

// Balance reliability and resource usage
const result = await agentbase.runAgent({
  message: `
    Download data efficiently:
    - Use cache when available (avoid unnecessary requests)
    - Implement aggressive timeout (fail fast on hung connections)
    - Limit retries to 3 attempts max
    - Use exponential backoff to avoid overwhelming services
  `,
  mode: "base"
});