Error Handling

class CircuitBreaker {
  private failures = 0
  private lastFailureTime = 0
  private state: 'closed' | 'open' | 'half-open' = 'closed'

  constructor(
    private failureThreshold: number = 5,
    private recoveryTimeout: number = 60000 // 1 minute
  ) {}

  async execute<T>(operation: () => Promise<T>): Promise<T> {
    if (this.state === 'open') {
      if (Date.now() - this.lastFailureTime > this.recoveryTimeout) {
        this.state = 'half-open'
      } else {
        throw new Error('Circuit breaker is OPEN - service unavailable')
      }
    }

    try {
      const result = await operation()
      this.onSuccess()
      return result
    } catch (error) {
      this.onFailure()
      throw error
    }
  }

  private onSuccess() {
    this.failures = 0
    this.state = 'closed'
  }

  private onFailure() {
    this.failures++
    this.lastFailureTime = Date.now()

    if (this.failures >= this.failureThreshold) {
      this.state = 'open'
    }
  }
}

// Usage in a tool
const apiCircuitBreaker = new CircuitBreaker(3, 30000) // 3 failures, 30s timeout

const resilientApiTool = new Tool({
  name: 'call_external_api',
  description: 'Make API calls with circuit breaker protection',
  schema: z.object({ endpoint: z.string() }),

  handler: async ({ endpoint }) => {
    try {
      return await apiCircuitBreaker.execute(() =>
        callExternalAPI(endpoint)
      )
    } catch (error) {
      if (error.message.includes('Circuit breaker is OPEN')) {
        return "Service temporarily unavailable. Please try again later."
      }
      return `API call failed: ${error.message}`
    }
  }
})

class RetryHandler {
  async executeWithRetry<T>(
    operation: () => Promise<T>,
    options: {
      maxAttempts: number
      baseDelay: number
      maxDelay: number
      backoffFactor: number
      retryCondition?: (error: any) => boolean
    }
  ): Promise<T> {
    let lastError: any

    for (let attempt = 1; attempt <= options.maxAttempts; attempt++) {
      try {
        return await operation()
      } catch (error) {
        lastError = error

        // Check if we should retry this error
        if (options.retryCondition && !options.retryCondition(error)) {
          throw error
        }

        // Don't retry on last attempt
        if (attempt === options.maxAttempts) {
          throw error
        }

        // Calculate delay with exponential backoff
        const delay = Math.min(
          options.baseDelay * Math.pow(options.backoffFactor, attempt - 1),
          options.maxDelay
        )

        // Add jitter to prevent thundering herd
        const jitteredDelay = delay * (0.5 + Math.random() * 0.5)

        await new Promise(resolve => setTimeout(resolve, jitteredDelay))
      }
    }

    throw lastError
  }
}

// Usage in tools
const retryHandler = new RetryHandler()

const databaseTool = new Tool({
  name: 'query_database',
  description: 'Execute database queries with retry logic',
  schema: z.object({ query: z.string() }),

  handler: async ({ query }) => {
    try {
      return await retryHandler.executeWithRetry(
        () => executeDatabaseQuery(query),
        {
          maxAttempts: 3,
          baseDelay: 1000, // 1 second
          maxDelay: 10000, // 10 seconds
          backoffFactor: 2,
          retryCondition: (error) =>
            error.code === 'CONNECTION_LOST' ||
            error.code === 'TIMEOUT'
        }
      )
    } catch (error) {
      return `Database query failed after retries: ${error.message}`
    }
  }
})

class FallbackHandler {
  async executeWithFallback<T>(
    primary: () => Promise<T>,
    fallbacks: Array<() => Promise<T>>,
    options: {
      fallbackCondition?: (error: any) => boolean
      onFallback?: (error: any, fallbackIndex: number) => void
    } = {}
  ): Promise<T> {
    let lastError: any

    // Try primary operation
    try {
      return await primary()
    } catch (error) {
      lastError = error
      if (options.fallbackCondition && !options.fallbackCondition(error)) {
        throw error
      }
    }

    // Try fallbacks in order
    for (let i = 0; i < fallbacks.length; i++) {
      try {
        options.onFallback?.(lastError, i)
        return await fallbacks[i]()
      } catch (error) {
        lastError = error
        // Continue to next fallback
      }
    }

    throw lastError
  }
}

// Usage example: Multiple data sources
const dataTool = new Tool({
  name: 'get_user_data',
  description: 'Retrieve user data with fallback sources',
  schema: z.object({ userId: z.string() }),

  handler: async ({ userId }) => {
    const fallbackHandler = new FallbackHandler()

    try {
      const data = await fallbackHandler.executeWithFallback(
        // Primary: Fast cache
        () => getUserFromCache(userId),

        // Fallbacks: Database, then external API
        [
          () => getUserFromDatabase(userId),
          () => getUserFromExternalAPI(userId)
        ],

        {
          fallbackCondition: (error) =>
            error.message.includes('not found') ||
            error.message.includes('timeout'),

          onFallback: (error, index) => {
            console.log(`Fallback ${index + 1} triggered: ${error.message}`)
          }
        }
      )

      return JSON.stringify(data)

    } catch (error) {
      return `Unable to retrieve user data: ${error.message}`
    }
  }
})