fantasy-cli 1.2.6

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

@@ -0,0 +1,396 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'json'
+
+module Gsd
+  module AI
+    module Providers
+      # OpenAI Provider - Integração com OpenAI API
+      #
+      # Suporta:
+      # - GPT-4 Turbo
+      # - GPT-4
+      # - GPT-3.5 Turbo
+      # - GPT-4 Vision
+      # - Streaming de respostas
+      # - Function calling
+      # - Token counting preciso
+      class OpenAI < Base
+        PROVIDER_NAME = 'OpenAI'
+        DEFAULT_MODEL = 'gpt-4-turbo-preview'
+        API_URL = 'https://api.openai.com/v1/chat/completions'
+        BASE_URL = 'https://api.openai.com'
+
+        # Modelos disponíveis com preços e capacidades
+        MODELS = {
+          'gpt-4-turbo-preview' => { 
+            input_price: 0.000_01, 
+            output_price: 0.000_03,
+            context_window: 128_000,
+            max_output: 4096,
+            vision: false,
+            caching: false
+          },
+          'gpt-4-vision-preview' => { 
+            input_price: 0.000_01, 
+            output_price: 0.000_03,
+            context_window: 128_000,
+            max_output: 4096,
+            vision: true,
+            caching: false
+          },
+          'gpt-4' => { 
+            input_price: 0.000_03, 
+            output_price: 0.000_06,
+            context_window: 8192,
+            max_output: 4096,
+            vision: false,
+            caching: false
+          },
+          'gpt-3.5-turbo' => { 
+            input_price: 0.000_000_5, 
+            output_price: 0.000_001_5,
+            context_window: 16385,
+            max_output: 4096,
+            vision: false,
+            caching: false
+          }
+        }.freeze
+
+        # Inicializa o provider OpenAI
+        #
+        # @param model [String] Modelo do GPT
+        # @param api_key [String] API key (ou use env OPENAI_API_KEY)
+        # @param debug [Boolean] Habilitar debug
+        # @param vision [Boolean] Habilitar suporte a vision
+        def initialize(model: nil, api_key: nil, debug: false, vision: false)
+          super(model: model, debug: debug)
+          @api_key = api_key || ENV['OPENAI_API_KEY']
+          @max_tokens = 4096
+          @vision = vision
+          @token_cache = {}
+        end
+
+        # Chama a API do OpenAI
+        #
+        # @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 OpenAI 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 OpenAIError, "OpenAI 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, 'OPENAI_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)
+          formatted_messages = [{ role: 'system', content: system_prompt }] +
+                               messages.map { |m| { role: m[:role], content: m[:content] } }
+
+          payload = {
+            model: @model,
+            max_tokens: @max_tokens,
+            messages: formatted_messages,
+            stream: stream
+          }
+
+          if tools.any?
+            payload[:tools] = format_tools(tools)
+            payload[:tool_choice] = 'auto'
+          end
+
+          payload
+        end
+
+        # Formata tools para API do OpenAI
+        #
+        # @param tools [Array] Tools
+        # @return [Array] Tools formatadas
+        def format_tools(tools)
+          tools.map do |tool|
+            {
+              type: 'function',
+              function: {
+                name: tool.name,
+                description: tool.description,
+                parameters: 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['Authorization'] = "Bearer #{@api_key}"
+          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 OpenAIError, "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['Authorization'] = "Bearer #{@api_key}"
+          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
+                    choice = event.dig(:choices, 0)
+                    if choice
+                      delta = choice[:delta]
+                      if delta
+                        content << delta[:content].to_s if delta[:content]
+
+                        # Tool calls
+                        if delta[:tool_calls]
+                          delta[:tool_calls].each do |tc|
+                            if tc[:function]
+                              tool_calls << {
+                                id: tc[:id],
+                                name: tc[:function][:name],
+                                arguments: tc[:function][:arguments].to_s
+                              }
+                            end
+                          end
+                        end
+                      end
+
+                      # Usage (vem no último chunk)
+                      if choice[:finish_reason]
+                        usage = extract_usage(event)
+                      end
+                    end
+                  rescue JSON::ParserError
+                    # Ignora linhas inválidas
+                  end
+                end
+              end
+            else
+              raise OpenAIError, "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
+        #
+        # @param text [String] Texto para contar
+        # @return [Integer] Número de tokens
+        def count_tokens(text)
+          return @token_cache[text] if @token_cache[text]
+
+          # Estimativa: ~4 caracteres por token para GPT
+          estimated = text.length / 4
+          @token_cache[text] = estimated
+          estimated
+        end
+
+        # Limpa o cache de tokens
+        #
+        # @return [void]
+        def clear_token_cache
+          @token_cache = {}
+        end
+
+        # Formata imagem para API do OpenAI (Vision)
+        #
+        # @param image_url [String] URL da imagem ou base64
+        # @param detail [String] Detail level (low, high, auto)
+        # @return [Hash] Conteúdo formatado
+        def format_image(image_url, detail: 'auto')
+          {
+            type: 'image_url',
+            image_url: {
+              url: image_url,
+              detail: detail
+            }
+          }
+        end
+
+        # Formata mensagem com texto e imagens
+        #
+        # @param text [String] Texto da mensagem
+        # @param images [Array] URLs ou base64 de imagens
+        # @return [Array] Conteúdo formatado
+        def format_message_with_images(text, images: [])
+          content = [{ type: 'text', text: text }]
+
+          images.each do |img|
+            content << format_image(img)
+          end
+
+          content
+        end
+
+        # Extrai texto da resposta
+        #
+        # @param data [Hash] Dados da resposta
+        # @return [String] Texto extraído
+        def extract_text(data)
+          choices = data['choices'] || []
+          return '' if choices.empty?
+
+          message = choices[0]['message'] || {}
+          message['content'] || ''
+        end
+
+        # Extrai tool calls da resposta
+        #
+        # @param data [Hash] Dados da resposta
+        # @return [Array] Tool calls
+        def extract_tool_calls(data)
+          choices = data['choices'] || []
+          return [] if choices.empty?
+
+          message = choices[0]['message'] || {}
+          tool_calls = message['tool_calls'] || []
+
+          tool_calls.map do |tc|
+            function = tc['function'] || {}
+            OpenStruct.new(
+              id: tc['id'],
+              name: function['name'],
+              arguments: JSON.parse(function['arguments'] || '{}')
+            )
+          end
+        rescue => e
+          log_debug("Error extracting tool calls: #{e.message}")
+          []
+        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['prompt_tokens'] || 0,
+            output_tokens: usage['completion_tokens'] || 0,
+            total_tokens: usage['total_tokens'] || 0
+          }
+        end
+      end
+
+      # Erro customizado para OpenAI
+      class OpenAIError < StandardError; end
+    end
+  end
+end