openaiext 0.0.8 → 0.0.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 001ae93d35a8aa13a2e2fe167e027849068c67e3b67e5691b0a1486ba32038b1
-  data.tar.gz: 4bee70a359b8b751a02cb293c0a200bb2775e303e2f96914bec7b8dd42bf3733
+  metadata.gz: 851fc779d886d1a1da353129d64c8203801faca4a34e83fd8a1829a49320ea37
+  data.tar.gz: 199b29d1dc970da2cbc9cf41d22fccd42d1aa42831b1c6b2b675e2d1de28457d
 SHA512:
-  metadata.gz: 25aacf4d31e2919c1d5e09d5c25335e29dfc2b0823b14e53087d26fa1172d5bd3671eb2006ec2c218220062328c4e51999d580bc0999c7732b2cf24c96ea8dd7
-  data.tar.gz: 97330fe2fc52929de29f8fb13dd46d2831e1b6a28761997552731f9a9abb87957504f36241ea83d7f6cdebe37891dafe45065494f0f1b4ab3029303b1f4088dd
+  metadata.gz: 2e48ece09e1d0b48f87a52d3d061eade56bba4736330566af4c82974575724585dc165ab98c8719c248ad003d27f2a439387f9e60b841a29b47b81857d5defde
+  data.tar.gz: 9a63dc77d5d19e94940a9b33ce1f17b67786f13ddcc7b8fe6fbf3a80934e9d4217a6e97886bbc9e4db27abc4ffb6de49adb6226d9c9c988fcee1eeca4e5c0559

data/lib/openaiext/messages.rb

@@ -1,34 +1,57 @@
 module OpenAIExt
   class Messages < Array
-    def initialize messages = nil
-      super parse_messages(messages)
+    VALID_ROLES = %w[system user assistant tool].freeze
+
+    def initialize(messages = nil)
+      super(parse_messages(messages))
     end
 
-    def add(message) = concat(parse_messages(message))
+    def add(message)
+      concat(parse_messages(message))
+    end
 
     private
+
     def parse_messages(messages)
       return [] if messages.nil?
 
       messages = [messages] unless messages.is_a?(Array)
-      
-      # if first element is ok, then do not parse the rest
-      return messages if messages.first in { role: String | Symbol, content: String | Array | Hash}
-
-      messages.flat_map do |msg|
-        if msg.is_a?(Hash)
-          if msg.keys.size == 1
-            role, content = msg.first
-            { role: role.to_s, content: content }
-          elsif msg.key?(:role) && msg.key?(:content)
-            { role: msg[:role].to_s, content: msg[:content] }
-          else
-            msg.map { |role, content| { role: role.to_s, content: content } }
-          end
-        else
-          raise ArgumentError, "Invalid message format: #{msg}"
-        end
+
+      # Verificação se a estrutura já está no formato esperado
+      return messages if messages.first.is_a?(Hash) && 
+                         messages.first.key?(:role) && 
+                         messages.first.key?(:content)
+
+      messages.flat_map { |msg| parse_message(msg) }
+    end
+
+    def parse_message(msg)
+      return parse_hash_message(msg) if msg.is_a?(Hash)
+      raise ArgumentError, "Formato de mensagem inválido: #{msg.inspect}"
+    end
+
+    def parse_hash_message(msg)
+      if msg.size == 1
+        role, content = msg.first
+        validate_and_format_message(role, content)
+      elsif msg.key?(:role) && msg.key?(:content)
+        validate_and_format_message(msg[:role], msg[:content])
+      else
+        msg.map { |role, content| validate_and_format_message(role, content) }
+      end
+    end
+
+    def validate_and_format_message(role, content)
+      role_str = role.to_s
+      unless VALID_ROLES.include?(role_str)
+        raise ArgumentError, "Role inválido: #{role_str}. Roles válidos: #{VALID_ROLES.join(', ')}"
       end
+
+      unless content.is_a?(String) || content.is_a?(Array) || content.is_a?(Hash)
+        raise ArgumentError, "Conteúdo inválido: #{content.inspect}"
+      end
+
+      { role: role_str, content: content }
     end
   end
 end

data/lib/openaiext/model.rb

@@ -1,27 +1,22 @@
 module OpenAIExt
   module Model
-    GPT_BASIC_MODEL = ENV.fetch('OPENAI_GPT_BASIC_MODEL', 'gpt-4o-mini')
-    GPT_ADVANCED_MODEL = ENV.fetch('OPENAI_GPT_ADVANCED_MODEL', 'gpt-4o')
+    GPT_BASIC_MODEL           = ENV.fetch('OPENAI_GPT_BASIC_MODEL', 'gpt-4o-mini')
+    GPT_ADVANCED_MODEL        = ENV.fetch('OPENAI_GPT_ADVANCED_MODEL', 'gpt-4o')
     GPT_ADVANCED_MODEL_LATEST = ENV.fetch('OPENAI_GPT_ADVANCED_MODEL_LATEST', 'chatgpt-4o-latest')
 
-    O1_BASIC_MODEL = ENV.fetch('OPENAI_O1_BASIC_MODEL', 'o1-mini')
-    O1_ADVANCED_MODEL = ENV.fetch('OPENAI_O1_ADVANCED_MODEL', 'o1-preview')
+    BASIC_REASONING_MODEL     = ENV.fetch('OPENAI_BASIC_REASONING_MODEL', 'o1-mini')
+    ADVANCED_REASONING_MODEL  = ENV.fetch('OPENAI_ADVANCED_REASONING_MODEL', 'o1-preview')
+
+    MODEL_MAP = {
+      gpt_basic:           GPT_BASIC_MODEL,
+      gpt_advanced:        GPT_ADVANCED_MODEL,
+      gpt_advanced_latest: GPT_ADVANCED_MODEL_LATEST,
+      reasoning_basic:     BASIC_REASONING_MODEL,
+      reasoning_advanced:  ADVANCED_REASONING_MODEL
+    }.freeze
 
     def self.select(model)
-      case model
-      when :gpt_basic
-        GPT_BASIC_MODEL
-      when :gpt_advanced
-        GPT_ADVANCED_MODEL
-      when :gpt_advanced_latest
-        GPT_ADVANCED_MODEL_LATEST
-      when :o1_basic
-        O1_BASIC_MODEL
-      when :o1_advanced
-        O1_ADVANCED_MODEL
-      else
-        model
-      end
+      MODEL_MAP.fetch(model, model)
     end
   end
 end

data/lib/openaiext/response_extender.rb

@@ -1,44 +1,62 @@
 module ResponseExtender
-  def chat_params = self[:chat_params]
+  def chat_params
+    self[:chat_params]
+  end
+
+  def message
+    dig('choices', 0, 'message')
+  end
 
-  def message = dig('choices', 0, 'message')
+  def content
+    dig('choices', 0, 'message', 'content')
+  end
 
-  def content = dig('choices', 0, 'message', 'content')
-  def content? = !content.nil?
+  def content?
+    !content.nil?
+  end
+
+  def tool_calls
+    dig('choices', 0, 'message', 'tool_calls')
+  end
 
-  def tool_calls = dig('choices', 0, 'message', 'tool_calls')
-  def tool_calls? = !tool_calls.nil?
+  def tool_calls?
+    !tool_calls.nil?
+  end
 
   def functions
-    return if tool_calls.nil?
-    
-    functions = tool_calls.filter { |tool| tool['type'].eql? 'function' }
-    return if functions.empty?
-    
-    functions_list = []
-    functions.map.with_index do |function, function_index|
-      function_info = tool_calls.dig(function_index, 'function')
-      function_def = { id: function['id'], name: function_info['name'], arguments: Oj.load(function_info['arguments'], symbol_keys: true) }
-      
-      def function_def.run(context:)
+    return [] unless tool_calls&.any?
+
+    tool_functions = tool_calls.select { |tool| tool['type'] == 'function' }
+    return [] if tool_functions.empty?
+
+    tool_functions.map do |function|
+      function_info = function['function']
+      function_def = {
+        id:        function['id'],
+        name:      function_info['name'],
+        arguments: Oj.load(function_info['arguments'], symbol_keys: true)
+      }
+
+      function_def.define_singleton_method(:run) do |context:|
         {
           tool_call_id: self[:id],
-          role: :tool,
-          name: self[:name],
-          content: context.send(self[:name], **self[:arguments])
+          role:         :tool,
+          name:         self[:name],
+          content:      Oj.dump(context.send(self[:name], **self[:arguments]))
         }
       end
 
-      functions_list << function_def
+      function_def
     end
-
-    functions_list
   end
 
   def functions_run_all(context:)
-    raise 'No functions to run' if functions.nil?
-    functions.map { |function| function.run(context:) }
+    raise 'Nenhuma função para executar' if functions.empty?
+
+    functions.map { |function| function.run(context: context) }
   end
 
-  def functions? = !functions.nil?
+  def functions?
+    functions.any?
+  end
 end

data/lib/openaiext.rb

@@ -1,82 +1,139 @@
 require 'openai'
-
 require 'openaiext/model'
 require 'openaiext/messages'
 require 'openaiext/response_extender'
-require 'openaiext/agent'
 
 module OpenAIExt
   MAX_TOKENS = ENV.fetch('OPENAI_MAX_TOKENS', 16_383).to_i
 
   def self.embeddings(input, model: 'text-embedding-3-large')
-    response = OpenAI::Client.new.embeddings(parameters: { input:, model: })
-    def response.embeddings = dig('data', 0, 'embedding')
+    client   = OpenAI::Client.new
+    response = client.embeddings(parameters: { input: input, model: model })
+    def response.embeddings
+      dig('data', 0, 'embedding')
+    end
     response
   end
 
-  def self.vision(prompt:, image_url:, model: :gpt_advanced, response_format: nil, max_tokens: MAX_TOKENS, store: true, metadata: nil, tools: nil, auto_run_functions: false, function_context: nil)
-    message_content = [{ type: :text, text: prompt }, { type: :image_url, image_url: { url: image_url } }]
-    chat(messages: [{ role: :user, content: message_content }], model:, response_format:, max_tokens:, store:, tools:, auto_run_functions:, function_context:)    
-  end  
+  def self.vision(prompt:, image_url:, model: :gpt_advanced, response_format: nil,
+                  max_tokens: MAX_TOKENS, store: true, metadata: nil, tools: nil,
+                  auto_run_functions: false, function_context: nil)
+    message_content = [
+      { type: :text, text: prompt },
+      { type: :image_url, image_url: { url: image_url } }
+    ]
+    chat(
+      messages:         [{ role: :user, content: message_content }],
+      model:            model,
+      response_format:  response_format,
+      max_tokens:       max_tokens,
+      store:            store,
+      tools:            tools,
+      auto_run_functions: auto_run_functions,
+      function_context: function_context
+    )
+  end
 
-  def self.single_prompt(prompt:, model: :gpt_basic, response_format: nil, max_tokens: MAX_TOKENS, store: true, metadata: nil, tools: nil, auto_run_functions: false, function_context: nil, temperature: nil, top_p: nil, frequency_penalty: nil, presence_penalty: nil, prediction: nil)
-    chat(messages: [{ user: prompt }], model:, response_format:, max_tokens:, store:, tools:, auto_run_functions:, function_context:, temperature:, top_p:, frequency_penalty:, presence_penalty:, prediction:)
+  def self.single_prompt(prompt:, model: :gpt_basic, response_format: nil,
+                         max_tokens: MAX_TOKENS, store: true, metadata: nil, tools: nil,
+                         auto_run_functions: false, function_context: nil, temperature: nil,
+                         top_p: nil, frequency_penalty: nil, presence_penalty: nil, prediction: nil)
+    chat(
+      messages:           [{ user: prompt }],
+      model:              model,
+      response_format:    response_format,
+      max_tokens:         max_tokens,
+      store:              store,
+      tools:              tools,
+      auto_run_functions: auto_run_functions,
+      function_context:   function_context,
+      temperature:        temperature,
+      top_p:              top_p,
+      frequency_penalty:  frequency_penalty,
+      presence_penalty:   presence_penalty,
+      prediction:         prediction
+    )
   end
 
-  def self.single_chat(system:, user:, model: :gpt_basic, response_format: nil, max_tokens: MAX_TOKENS, store: true, metadata: nil, tools: nil, auto_run_functions: false, function_context: nil, temperature: nil, top_p: nil, frequency_penalty: nil, presence_penalty: nil, prediction: nil)
-    chat(messages: [{ system: }, { user: }], model:, response_format:, max_tokens:, store:, tools:, auto_run_functions:, function_context:, temperature:, top_p:, frequency_penalty:, presence_penalty:, prediction:)
+  def self.single_chat(system:, user:, model: :gpt_basic, response_format: nil,
+                       max_tokens: MAX_TOKENS, store: true, metadata: nil, tools: nil,
+                       auto_run_functions: false, function_context: nil, temperature: nil,
+                       top_p: nil, frequency_penalty: nil, presence_penalty: nil, prediction: nil)
+    chat(
+      messages:           [{ system: system }, { user: user }],
+      model:              model,
+      response_format:    response_format,
+      max_tokens:         max_tokens,
+      store:              store,
+      tools:              tools,
+      auto_run_functions: auto_run_functions,
+      function_context:   function_context,
+      temperature:        temperature,
+      top_p:              top_p,
+      frequency_penalty:  frequency_penalty,
+      presence_penalty:   presence_penalty,
+      prediction:         prediction
+    )
   end
 
-  def self.chat(messages:, model: :gpt_basic, response_format: nil, max_tokens: MAX_TOKENS, store: true, metadata: nil, tools: nil, auto_run_functions: false, function_context: nil, temperature: nil, top_p: nil, frequency_penalty: nil, presence_penalty: nil, prediction: nil)
-    model = OpenAIExt::Model.select(model)
-    is_o1_model = model.start_with?('o1')
+  def self.chat(messages:, model: :gpt_basic, response_format: nil, max_tokens: MAX_TOKENS,
+                store: true, metadata: nil, tools: nil, auto_run_functions: false,
+                function_context: nil, temperature: nil, top_p: nil, frequency_penalty: nil,
+                presence_penalty: nil, prediction: nil)
+    selected_model = OpenAIExt::Model.select(model)
+    is_reasoning_model = selected_model.start_with?('o')
 
     messages = OpenAIExt::Messages.new(messages) unless messages.is_a?(OpenAIExt::Messages)
-    
-    parameters = { model:, messages:, store: }
-    parameters[:metadata] = metadata if metadata
 
-    # o1 family models doesn't support max_tokens params. Instead, use max_completion_tokens
-    parameters[:max_completion_tokens] = max_tokens if is_o1_model
-    parameters[:max_tokens] = max_tokens unless is_o1_model
+    parameters = { model: selected_model, messages: messages, store: store }
+    parameters[:metadata] = metadata if metadata
 
-    parameters[:response_format] = { type: 'json_object' } if response_format.eql?(:json)
-    parameters[:tools] = tools if tools
+    if is_reasoning_model
+      parameters[:max_completion_tokens] = max_tokens
+    else
+      parameters[:max_tokens] = max_tokens
+    end
 
-    parameters[:temperature] = temperature if temperature
-    parameters[:top_p] = top_p if top_p
-    parameters[:frequency_penalty] = frequency_penalty if frequency_penalty
-    parameters[:presence_penalty] = presence_penalty if presence_penalty
-    parameters[:prediction] = prediction if prediction
+    parameters[:response_format]    = { type: 'json_object' } if response_format == :json
+    parameters[:tools]              = tools if tools
+    parameters[:temperature]        = temperature       if temperature
+    parameters[:top_p]              = top_p             if top_p
+    parameters[:frequency_penalty]  = frequency_penalty if frequency_penalty
+    parameters[:presence_penalty]   = presence_penalty  if presence_penalty
+    parameters[:prediction]         = prediction        if prediction
 
     begin
-      response = OpenAI::Client.new.chat(parameters:)
-    rescue => e
-      raise "Error in OpenAI chat: #{e.message}\nParameters: #{parameters.inspect}"
+      client   = OpenAI::Client.new
+      response = client.chat(parameters: parameters)
+    rescue StandardError => e
+      raise "Erro na comunicação com OpenAI: #{e.message}\nParâmetros: #{parameters.inspect}"
     end
-    
-    response[:chat_params] = parameters   
+
+    response[:chat_params] = parameters
     response.extend(ResponseExtender)
 
     if response.functions? && auto_run_functions
-      raise 'Function context not provided for auto-running functions' if function_context.nil?
+      raise 'Contexto para funções não informado para execução automática' if function_context.nil?
+
       parameters[:messages] << response.message
       parameters[:messages] += response.functions_run_all(context: function_context)
 
-      response = chat(**parameters.except(:chat_params))
+      response = chat(**parameters.reject { |k, _| k == :chat_params })
     end
-   
+
     response
   end
 
-  def self.models = OpenAI::Client.new.models.list
+  def self.models
+    OpenAI::Client.new.models.list
+  end
 
   def self.load_config
     OpenAI.configure do |config|
-      config.access_token = ENV.fetch('OPENAI_ACCESS_TOKEN')
-      config.organization_id = ENV.fetch('OPENAI_ORGANIZATION_ID')
-      config.request_timeout = 300
-      config.log_errors = true
+      config.access_token      = ENV.fetch('OPENAI_ACCESS_TOKEN')
+      config.organization_id   = ENV.fetch('OPENAI_ORGANIZATION_ID')
+      config.request_timeout   = 300
+      config.log_errors        = true
     end
   end
 end

metadata

@@ -1,11 +1,10 @@
 --- !ruby/object:Gem::Specification
 name: openaiext
 version: !ruby/object:Gem::Version
-  version: 0.0.8
+  version: 0.0.9
 platform: ruby
 authors:
 - Gedean Dias
-autorequire: 
 bindir: bin
 cert_chain: []
 date: 2024-11-07 00:00:00.000000000 Z
@@ -46,7 +45,6 @@ extra_rdoc_files: []
 files:
 - README.md
 - lib/openaiext.rb
-- lib/openaiext/agent.rb
 - lib/openaiext/messages.rb
 - lib/openaiext/model.rb
 - lib/openaiext/response_extender.rb
@@ -54,7 +52,6 @@ homepage: https://github.com/gedean/openaiext
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -69,8 +66,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.23
-signing_key: 
+rubygems_version: 3.6.3
 specification_version: 4
 summary: Ruby OpenAI Extended
 test_files: []

data/lib/openaiext/agent.rb

@@ -1,64 +0,0 @@
-module OpenAIExt
-  class Agent
-    extend OpenAI
-    
-    attr_reader :assistant, :thread, :instructions, :vector_store_id
-
-    def initialize(assistant_id: nil, thread_id: nil, thread_instructions: nil, vector_store_id: nil)
-      @openai_client = OpenAI::Client.new
-
-      assistant_id ||= ENV.fetch('OPENAI_ASSISTANT_ID')
-      @assistant = @openai_client.assistants.retrieve(id: assistant_id)
-
-      thread_params = {}
-
-      # Only one vector store can be attached, according to the OpenAI API documentation
-      @vector_store_id = vector_store_id
-      thread_params = { tool_resources: { file_search: { vector_store_ids: [vector_store_id] } } } if @vector_store_id
-
-      thread_id ||= @openai_client.threads.create(parameters: thread_params)['id']
-      @thread = @openai_client.threads.retrieve(id: thread_id)
-
-      @instructions = thread_instructions || @assistant['instructions']
-    end
-
-    def add_message(text, role: 'user') = @openai_client.messages.create(thread_id: @thread['id'], parameters: { role: role, content: text })
-    def messages = @openai_client.messages.list(thread_id: @thread['id'])
-    def last_message = messages['data'].first['content'].first['text']['value']
-    def runs = @openai_client.runs.list(thread_id: @thread['id'])
-
-    def run(instructions: nil, additional_instructions: nil, additional_message: nil, model: nil, tool_choice: nil)
-      params = { assistant_id: @assistant['id'] }
-
-      params[:instructions] = instructions || @instructions
-      params[:additional_instructions] = additional_instructions unless additional_instructions.nil?
-      params[:tool_choice] = tool_choice unless tool_choice.nil?
-
-      params[:additional_messages] = [{ role: :user, content: additional_message }] unless additional_message.nil?
-
-      params[:model] = OpenAIExt::Model.select(model) || @assistant['model']
-
-      run_id = @openai_client.runs.create(thread_id: @thread['id'], parameters: params)['id']
-
-      loop do
-        response = @openai_client.runs.retrieve(id: run_id, thread_id: @thread['id'])
-
-        case response['status']
-        when 'queued', 'in_progress', 'cancelling'
-          puts 'Status: Waiting AI Processing finish'
-          sleep 1
-        when 'completed'
-          puts last_message
-          break
-        when 'requires_action'
-          # Handle tool calls (see below)
-        when 'cancelled', 'failed', 'expired'
-          puts response['last_error'].inspect
-          break # or `exit`
-        else
-          puts "Unknown status response: #{status}"
-        end
-      end
-    end
-  end
-end