fantasy-cli 1.2.6

data/lib/gsd/ai/providers/anthropic.rb

@@ -0,0 +1,429 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'json'
+
+module Gsd
+  module AI
+    module Providers
+      # Anthropic Provider - Integração com Claude API
+      #
+      # Suporta:
+      # - Claude 3.5 Sonnet
+      # - Claude 3 Opus
+      # - Claude 3 Haiku
+      # - Streaming de respostas
+      # - Tool use
+      # - Prompt caching (beta)
+      # - Vision (imagens)
+      # - Beta features
+      class Anthropic < Base
+        PROVIDER_NAME = 'Anthropic'
+        DEFAULT_MODEL = 'claude-sonnet-4-5-20250929'
+        API_URL = 'https://api.anthropic.com/v1/messages'
+        BASE_URL = 'https://api.anthropic.com'
+
+        # Modelos disponíveis com preços e capacidades
+        MODELS = {
+          'claude-sonnet-4-5-20250929' => { 
+            input_price: 0.000_003, 
+            output_price: 0.000_015,
+            context_window: 200_000,
+            max_output: 8192,
+            vision: true,
+            caching: true
+          },
+          'claude-3-opus-20240229' => { 
+            input_price: 0.000_015, 
+            output_price: 0.000_075,
+            context_window: 200_000,
+            max_output: 4096,
+            vision: true,
+            caching: true
+          },
+          'claude-3-haiku-20240307' => { 
+            input_price: 0.000_000_25, 
+            output_price: 0.000_001_25,
+            context_window: 200_000,
+            max_output: 4096,
+            vision: true,
+            caching: true
+          }
+        }.freeze
+
+        # Beta features disponíveis
+        BETA_FEATURES = [
+          'prompt-caching-2024-07-31',
+          'computer-use-2024-10-22'
+        ].freeze
+
+        # Inicializa o provider Anthropic
+        #
+        # @param model [String] Modelo do Claude
+        # @param api_key [String] API key (ou use env ANTHROPIC_API_KEY)
+        # @param debug [Boolean] Habilitar debug
+        # @param beta [Boolean] Habilitar beta features
+        # @param cache_system_prompt [Boolean] Cache de system prompt
+        def initialize(model: nil, api_key: nil, debug: false, beta: false, cache_system_prompt: true)
+          super(model: model, debug: debug)
+          @api_key = api_key || ENV['ANTHROPIC_API_KEY']
+          @max_tokens = 4096
+          @beta = beta
+          @cache_system_prompt = cache_system_prompt
+          @token_cache = {} # Cache para token counting
+        end
+
+        # Chama a API do Anthropic
+        #
+        # @param system_prompt [String] System prompt
+        # @param messages [Array] Histórico de mensagens
+        # @param tools [Array] Tools disponíveis
+        # @param stream [Boolean] Habilitar streaming
+        # @yield [Hash] Chunk de streaming
+        # @return [OpenStruct] Resposta
+        def call(system_prompt:, messages:, tools:, stream: false, &block)
+          validate_api_key!
+
+          payload = build_payload(system_prompt, messages, tools, stream)
+
+          log_debug("Calling Anthropic API with model: #{@model}")
+          log_debug("Messages count: #{messages.count}")
+          log_debug("Tools count: #{tools.count}") if tools.any?
+
+          if stream
+            stream_request(payload, &block)
+          else
+            sync_request(payload)
+          end
+        rescue => e
+          log_debug("Error: #{e.message}")
+          raise AnthropicError, "Anthropic API error: #{e.message}"
+        end
+
+        # Verifica se está configurado
+        #
+        # @return [Boolean] true se configurado
+        def configured?
+          !@api_key.nil? && !@api_key.empty?
+        end
+
+        # Retorna o preço do modelo
+        #
+        # @return [Hash] Preço de input e output
+        def pricing
+          MODELS[@model] || { input_price: 0, output_price: 0 }
+        end
+
+        private
+
+        # Valida API key
+        #
+        # @raise [ArgumentError] Se API key não estiver configurada
+        def validate_api_key!
+          raise ArgumentError, 'ANTHROPIC_API_KEY not set' unless configured?
+        end
+
+        # Constrói o payload da requisição
+        #
+        # @param system_prompt [String] System prompt
+        # @param messages [Array] Mensagens
+        # @param tools [Array] Tools
+        # @param stream [Boolean] Streaming
+        # @return [Hash] Payload
+        def build_payload(system_prompt, messages, tools, stream)
+          payload = {
+            model: @model,
+            max_tokens: @max_tokens,
+            messages: format_messages_with_cache(messages),
+            stream: stream
+          }
+
+          # System prompt com cache (beta)
+          if @cache_system_prompt && system_prompt && !system_prompt.empty?
+            payload[:system] = [
+              {
+                type: 'text',
+                text: system_prompt,
+                cache_control: { type: 'ephemeral' }
+              }
+            ]
+          else
+            payload[:system] = system_prompt
+          end
+
+          # Tools
+          if tools.any?
+            payload[:tools] = format_tools(tools)
+          end
+
+          # Beta headers
+          if @beta
+            payload[:betas] = BETA_FEATURES
+          end
+
+          payload
+        end
+
+        # Formata mensagens para API do Anthropic
+        #
+        # @param messages [Array] Mensagens
+        # @return [Array] Mensagens formatadas
+        def format_messages(messages)
+          messages.map do |msg|
+            {
+              role: msg[:role] == 'assistant' ? 'assistant' : 'user',
+              content: msg[:content]
+            }
+          end
+        end
+
+        # Formata tools para API do Anthropic
+        #
+        # @param tools [Array] Tools
+        # @return [Array] Tools formatadas
+        def format_tools(tools)
+          tools.map do |tool|
+            {
+              name: tool.name,
+              description: tool.description,
+              input_schema: tool.input_schema || { type: 'object', properties: {} }
+            }
+          end
+        end
+
+        # Faz requisição síncrona
+        #
+        # @param payload [Hash] Payload da requisição
+        # @return [OpenStruct] Resposta
+        def sync_request(payload)
+          uri = URI(API_URL)
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = true
+
+          request = Net::HTTP::Post.new(uri.path)
+          request['Content-Type'] = 'application/json'
+          request['x-api-key'] = @api_key
+          request['anthropic-version'] = '2023-06-01'
+          request.body = JSON.generate(payload)
+
+          log_debug("Sending request to #{API_URL}")
+
+          response = http.request(request)
+          log_debug("Response status: #{response.code}")
+
+          if response.code == '200'
+            parse_response(JSON.parse(response.body))
+          else
+            raise AnthropicError, "API error: #{response.code} - #{response.body}"
+          end
+        end
+
+        # Faz requisição com streaming
+        #
+        # @param payload [Hash] Payload da requisição
+        # @yield [Hash] Chunk de streaming
+        # @return [OpenStruct] Resposta
+        def stream_request(payload, &block)
+          uri = URI(API_URL)
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = true
+
+          request = Net::HTTP::Post.new(uri.path)
+          request['Content-Type'] = 'application/json'
+          request['x-api-key'] = @api_key
+          request['anthropic-version'] = '2023-06-01'
+          request.body = JSON.generate(payload)
+
+          log_debug("Sending streaming request to #{API_URL}")
+
+          content = +''
+          tool_calls = []
+          usage = {}
+
+          # Streaming com Server-Sent Events (SSE)
+          http.request(request) do |response|
+            if response.code == '200'
+              response.read_body do |chunk|
+                chunk.each_line do |line|
+                  line = line.strip
+                  next if line.empty?
+                  next unless line.start_with?('data: ')
+
+                  data = line[6..-1]
+                  next if data == '[DONE]'
+
+                  begin
+                    event = JSON.parse(data)
+                    yield(event) if block_given?
+
+                    # Acumula conteúdo
+                    if event[:type] == 'content_block_delta'
+                      text = event.dig(:delta, :text)
+                      content << text if text
+                    elsif event[:type] == 'content_block_start'
+                      if event.dig(:content_block, :type) == 'tool_use'
+                        tool_calls << {
+                          id: event.dig(:content_block, :id),
+                          name: event.dig(:content_block, :name),
+                          input: ''
+                        }
+                      end
+                    elsif event[:type] == 'message_delta'
+                      usage = extract_usage(event)
+                    end
+                  rescue JSON::ParserError
+                    # Ignora linhas inválidas
+                  end
+                end
+              end
+            else
+              raise AnthropicError, "API error: #{response.code}"
+            end
+          end
+
+          OpenStruct.new(
+            content: content,
+            tool_calls: tool_calls,
+            usage: usage,
+            raw: {}
+          )
+        end
+
+        # Parseia a resposta da API
+        #
+        # @param data [Hash] Dados da resposta
+        # @return [OpenStruct] Resposta parseada
+        def parse_response(data)
+          content = extract_text(data)
+          tool_calls = extract_tool_calls(data)
+          usage = extract_usage(data)
+
+          OpenStruct.new(
+            content: content,
+            tool_calls: tool_calls,
+            usage: usage,
+            raw: data
+          )
+        end
+
+        # Conta tokens de forma precisa usando API do Anthropic
+        #
+        # @param text [String] Texto para contar
+        # @return [Integer] Número de tokens
+        def count_tokens(text)
+          # Cache simples
+          return @token_cache[text] if @token_cache[text]
+
+          # Estimativa rápida: ~4 caracteres por token
+          estimated = text.length / 4
+
+          # Para contagem precisa, usaríamos a API de count_tokens
+          # Por enquanto, usamos estimativa com margem de erro
+          @token_cache[text] = estimated
+          estimated
+        end
+
+        # Limpa o cache de tokens
+        #
+        # @return [void]
+        def clear_token_cache
+          @token_cache = {}
+        end
+
+        # Formata mensagem com cache de prompt (beta)
+        #
+        # @param messages [Array] Mensagens
+        # @return [Array] Mensagens formatadas com cache
+        def format_messages_with_cache(messages)
+          return format_messages(messages) unless @cache_system_prompt
+
+          # Aplica cache às mensagens antigas (últimas 2-3 mensagens sem cache)
+          messages.map.with_index do |msg, i|
+            formatted = {
+              role: msg[:role] == 'assistant' ? 'assistant' : 'user',
+              content: msg[:content]
+            }
+
+            # Adiciona cache para mensagens antigas (exceto as últimas 2)
+            if i < messages.length - 2
+              formatted[:content] = [
+                {
+                  type: 'text',
+                  text: msg[:content],
+                  cache_control: { type: 'ephemeral' }
+                }
+              ]
+            end
+
+            formatted
+          end
+        end
+
+        # Formata imagem para API do Anthropic
+        #
+        # @param source [Hash] Source da imagem (type, media_type, data)
+        # @return [Hash] Conteúdo formatado
+        def format_image(source)
+          {
+            type: 'image',
+            source: source
+          }
+        end
+
+        # Extrai texto da resposta
+        #
+        # @param data [Hash] Dados da resposta
+        # @return [String] Texto extraído
+        def extract_text(data)
+          content_blocks = data['content'] || []
+          text_blocks = content_blocks.select { |b| b['type'] == 'text' }
+          text_blocks.map { |b| b['text'] }.join("\n")
+        end
+
+        # Extrai tool calls da resposta
+        #
+        # @param data [Hash] Dados da resposta
+        # @return [Array] Tool calls
+        def extract_tool_calls(data)
+          content_blocks = data['content'] || []
+          tool_blocks = content_blocks.select { |b| b['type'] == 'tool_use' }
+
+          tool_blocks.map do |block|
+            # Parseia input se for string JSON
+            input = block['input']
+            if input.is_a?(String)
+              begin
+                input = JSON.parse(input)
+              rescue JSON::ParserError
+                # Mantém como string se não for JSON válido
+              end
+            end
+
+            OpenStruct.new(
+              id: block['id'],
+              name: block['name'],
+              arguments: input || {}
+            )
+          end
+        end
+
+        # Extrai usage da resposta
+        #
+        # @param data [Hash] Dados da resposta
+        # @return [Hash] Usage data
+        def extract_usage(data)
+          usage = data['usage'] || {}
+          {
+            input_tokens: usage['input_tokens'] || 0,
+            output_tokens: usage['output_tokens'] || 0,
+            cache_read_input_tokens: usage['cache_read_input_tokens'] || 0,
+            cache_creation_input_tokens: usage['cache_creation_input_tokens'] || 0
+          }
+        end
+      end
+
+      # Erro customizado para Anthropic
+      class AnthropicError < StandardError; end
+    end
+  end
+end

data/lib/gsd/ai/providers/base.rb

@@ -0,0 +1,282 @@
+# frozen_string_literal: true
+
+require 'timeout'
+
+module Gsd
+  module AI
+    module Providers
+      # Base class para todos os providers de LLM
+      #
+      # Responsável por:
+      # - Interface comum para diferentes providers
+      # - Tratamento de erros genérico
+      # - Logging e debug
+      # - Retry com backoff exponencial
+      # - Rate limiting
+      # - Timeout de requisições
+      # - Fallback para providers alternativos
+      class Base
+        attr_accessor :model, :debug, :timeout, :max_retries
+        attr_reader :rate_limiter
+
+        # Configurações padrão
+        DEFAULT_TIMEOUT = 120 # segundos
+        DEFAULT_MAX_RETRIES = 3
+        DEFAULT_RATE_LIMIT = 10 # requisições por minuto
+        PROVIDER_NAME = 'Unknown' # Nome padrão para providers sem nome específico
+
+        # Inicializa o provider
+        #
+        # @param model [String] Modelo do LLM
+        # @param debug [Boolean] Habilitar debug
+        # @param timeout [Integer] Timeout em segundos
+        # @param max_retries [Integer] Número máximo de tentativas
+        # @param rate_limit [Integer] Limite de requisições por minuto
+        def initialize(model: nil, debug: false, timeout: nil, max_retries: nil, rate_limit: nil)
+          @model = model || self.class::DEFAULT_MODEL
+          @debug = debug
+          @timeout = timeout || DEFAULT_TIMEOUT
+          @max_retries = max_retries || DEFAULT_MAX_RETRIES
+          @rate_limiter = RateLimiter.new(rate_limit || DEFAULT_RATE_LIMIT)
+          @api_key = nil
+          @client = nil
+          @fallback_provider = nil
+        end
+
+        # Chama o LLM
+        #
+        # @param system_prompt [String] System prompt
+        # @param messages [Array] Histórico de mensagens
+        # @param tools [Array] Tools disponíveis
+        # @param stream [Boolean] Habilitar streaming
+        # @yield [Hash] Chunk de streaming (se stream=true)
+        # @return [OpenStruct] Resposta com content, tool_calls, usage
+        def call(system_prompt:, messages:, tools:, stream: false, &block)
+          raise NotImplementedError, 'Subclasses must implement #call'
+        end
+
+        # Chama o LLM com retry e fallback
+        #
+        # @param system_prompt [String] System prompt
+        # @param messages [Array] Histórico de mensagens
+        # @param tools [Array] Tools disponíveis
+        # @param stream [Boolean] Habilitar streaming
+        # @yield [Hash] Chunk de streaming
+        # @return [OpenStruct] Resposta
+        def call_with_retry(system_prompt:, messages:, tools:, stream: false, &block)
+          last_error = nil
+
+          @max_retries.times do |attempt|
+            begin
+              # Rate limiting
+              @rate_limiter.wait_if_needed
+
+              # Timeout
+              return Timeout.timeout(@timeout) do
+                call(system_prompt: system_prompt, messages: messages, tools: tools, stream: stream, &block)
+              end
+            rescue Timeout::Error => e
+              log_debug("Timeout na tentativa #{attempt + 1}: #{e.message}")
+              last_error = e
+              retry if attempt < @max_retries - 1
+            rescue => e
+              log_debug("Erro na tentativa #{attempt + 1}: #{e.message}")
+              last_error = e
+
+              # Backoff exponencial
+              if attempt < @max_retries - 1
+                wait_time = exponential_backoff(attempt)
+                log_debug("Aguardando #{wait_time}s antes de retry...")
+                sleep(wait_time)
+              end
+            end
+          end
+
+          # Fallback se configurado
+          if @fallback_provider && last_error
+            log_debug("Usando fallback provider...")
+            return @fallback_provider.call(
+              system_prompt: system_prompt,
+              messages: messages,
+              tools: tools,
+              stream: stream,
+              &block
+            )
+          end
+
+          raise last_error if last_error
+
+          nil
+        end
+
+        # Define um provider de fallback
+        #
+        # @param provider [Base] Provider de fallback
+        # @return [void]
+        def fallback=(provider)
+          @fallback_provider = provider
+        end
+
+        # Verifica se o provider está configurado
+        #
+        # @return [Boolean] true se configurado
+        def configured?
+          !@api_key.nil? && !@api_key.empty?
+        end
+
+        # Retorna informações do provider
+        #
+        # @return [Hash] Informações
+        def info
+          {
+            provider: self.class::PROVIDER_NAME,
+            model: @model,
+            configured: configured?,
+            timeout: @timeout,
+            max_retries: @max_retries,
+            rate_limit: @rate_limiter.limit
+          }
+        end
+
+        # Reseta o rate limiter
+        #
+        # @return [void]
+        def reset_rate_limiter
+          @rate_limiter.reset
+        end
+
+        protected
+
+        # Log de debug
+        #
+        # @param message [String] Mensagem de log
+        def log_debug(message)
+          return unless @debug
+
+          puts "[DEBUG][#{self.class::PROVIDER_NAME}] #{message}"
+        end
+
+        # Calcula backoff exponencial
+        #
+        # @param attempt [Integer] Número da tentativa
+        # @return [Float] Tempo de espera em segundos
+        def exponential_backoff(attempt)
+          # Backoff: 1s, 2s, 4s, 8s, ...
+          base = 1.0
+          (base * (2 ** attempt)).to_f
+        end
+
+        # Extrai texto de uma resposta
+        #
+        # @param response [Object] Resposta da API
+        # @return [String] Texto extraído
+        def extract_text(response)
+          raise NotImplementedError, 'Subclasses must implement #extract_text'
+        end
+
+        # Extrai tool calls de uma resposta
+        #
+        # @param response [Object] Resposta da API
+        # @return [Array] Tool calls
+        def extract_tool_calls(response)
+          []
+        end
+
+        # Extrai usage de uma resposta
+        #
+        # @param response [Object] Resposta da API
+        # @return [Hash] Usage data
+        def extract_usage(response)
+          {
+            input_tokens: 0,
+            output_tokens: 0
+          }
+        end
+      end
+
+      # Rate Limiter - Controla taxa de requisições
+      #
+      # Implementa token bucket algorithm para rate limiting
+      class RateLimiter
+        attr_reader :limit, :tokens, :last_refill
+
+        # Inicializa o rate limiter
+        #
+        # @param limit [Integer] Requisições por minuto
+        def initialize(limit)
+          @limit = limit
+          @tokens = limit.to_f
+          @last_refill = Time.now
+        end
+
+        # Verifica se pode fazer requisição
+        #
+        # @return [Boolean] true se pode fazer requisição
+        def can_make_request?
+          refill_tokens
+          @tokens >= 1
+        end
+
+        # Aguarda se necessário antes de fazer requisição
+        #
+        # @return [void]
+        def wait_if_needed
+          until can_make_request?
+            sleep(0.1)
+          end
+
+          @tokens -= 1
+        end
+
+        # Reseta o rate limiter
+        #
+        # @return [void]
+        def reset
+          @tokens = @limit.to_f
+          @last_refill = Time.now
+        end
+
+        # Retorna tempo estimado até próxima requisição
+        #
+        # @return [Float] Tempo em segundos
+        def time_until_next_request
+          refill_tokens
+          return 0 if @tokens >= 1
+
+          tokens_needed = 1 - @tokens
+          tokens_per_second = @limit / 60.0
+          tokens_needed / tokens_per_second
+        end
+
+        private
+
+        # Refill tokens baseado no tempo passado
+        #
+        # @return [void]
+        def refill_tokens
+          now = Time.now
+          elapsed = now - @last_refill
+
+          # Tokens por segundo
+          tokens_per_second = @limit / 60.0
+          tokens_to_add = elapsed * tokens_per_second
+
+          @tokens = [@limit, @tokens + tokens_to_add].min
+          @last_refill = now
+        end
+      end
+
+      # Erro base para providers
+      class ProviderError < StandardError; end
+
+      # Erro de rate limit
+      class RateLimitError < ProviderError; end
+
+      # Erro de timeout
+      class TimeoutError < ProviderError; end
+
+      # Erro de autenticação
+      class AuthenticationError < ProviderError; end
+    end
+  end
+end