openaiext 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4622de30e5df0ef4fd41d49f329dd9ec64ca84f87bf8be59dbf3301e75b99429
+  data.tar.gz: fbd7a1741c752c1852f7d7962aaa44bb2dcbf641029de864963783d3b3d2f6a4
+SHA512:
+  metadata.gz: bd2d2f0ccda1be4e864414de652fbb628f16b172e786d6f8ba45266009829ceda9dacd9996a9af12bf2be63f2eb322363374942b5d6ddbac3edbca5bc61edbdb
+  data.tar.gz: 0ad5bb389487ccd355ae6cb0ac23080eb713b465434b189fe7c86ecedab1301ad7dbd7106ca24c2e5f26c8e2a1223b44a827774df8b14d6d007020fad428b1c4

data/README.md

@@ -0,0 +1 @@
+# openaiext

data/lib/openaiext/agent.rb

@@ -0,0 +1,64 @@
+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] = 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

data/lib/openaiext/messages.rb

@@ -0,0 +1,34 @@
+module OpenAIExt
+  class Messages < Array
+    def initialize messages = nil
+      super parse_messages(messages)
+    end
+
+    def add(message) = concat(parse_messages(message))
+
+    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
+      end
+    end
+  end
+end

data/lib/openaiext/response_extender.rb

@@ -0,0 +1,44 @@
+module ResponseExtender
+  def chat_params = self[:chat_params]
+
+  def message = dig('choices', 0, 'message')
+
+  def content = dig('choices', 0, 'message', 'content')
+  def content? = !content.nil?
+
+  def tool_calls = dig('choices', 0, 'message', 'tool_calls')
+  def tool_calls? = !tool_calls.nil?
+
+  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:)
+        {
+          tool_call_id: self[:id],
+          role: :tool,
+          name: self[:name],
+          content: context.send(self[:name], **self[:arguments])
+        }
+      end
+
+      functions_list << 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:) }
+  end
+
+  def functions? = !functions.nil?
+end

data/lib/openaiext.rb

@@ -0,0 +1,87 @@
+require 'openai'
+
+require 'openaiext/messages'
+require 'openaiext/response_extender'
+require 'openaiext/agent'
+
+module OpenAIExt
+  GPT_BASIC_MODEL = ENV.fetch('OPENAI_GPT_BASIC_MODEL', 'gpt-4o-mini')
+  GPT_ADVANCED_MODEL = ENV.fetch('OPENAI_GPT_ADVANCED_MODEL', 'gpt-4o-2024-08-06')
+
+  O1_BASIC_MODEL = ENV.fetch('OPENAI_O1_BASIC_MODEL', 'o1-mini')
+  O1_ADVANCED_MODEL = ENV.fetch('OPENAI_O1_ADVANCED_MODEL', 'o1-preview')
+  
+  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')
+    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.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)
+    chat(messages: [{ user: prompt }], model:, response_format:, max_tokens:, store:, tools:, auto_run_functions:, function_context:)
+  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)
+    chat(messages: [{ system: }, { user: }], model:, response_format:, max_tokens:, store:, tools:, auto_run_functions:, function_context:)
+  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)
+    model = select_model(model)
+    is_o1_model = model.start_with?('o1')
+
+    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[:response_format] = { type: 'json_object' } if response_format.eql?(:json)
+    parameters[:tools] = tools if tools
+
+    begin
+      response = OpenAI::Client.new.chat(parameters:)
+    rescue => e
+      raise "Error in OpenAI chat: #{e.message}\nParameters: #{parameters.inspect}"
+    end
+    
+    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?
+      parameters[:messages] << response.message
+      parameters[:messages] += response.functions_run_all(context: function_context)
+
+      response = chat(**parameters.except(:chat_params))
+    end
+   
+    response
+  end
+
+  def self.models = OpenAI::Client.new.models.list
+
+  def self.select_model(model)
+    case model
+    when :gpt_basic
+      GPT_BASIC_MODEL
+    when :gpt_advanced
+      GPT_ADVANCED_MODEL
+    when :o1_basic
+      O1_BASIC_MODEL
+    when :o1_advanced
+      O1_ADVANCED_MODEL
+    else
+      model
+    end
+  end
+end

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification
+name: openaiext
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Gedean Dias
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2024-10-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ruby-openai
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.3'
+- !ruby/object:Gem::Dependency
+  name: anthropic
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+- !ruby/object:Gem::Dependency
+  name: oj
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+description: Based on ruby-openai, adds some extra features
+email: gedean.dias@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/openaiext.rb
+- lib/openaiext/agent.rb
+- lib/openaiext/messages.rb
+- lib/openaiext/response_extender.rb
+homepage: https://github.com/gedean/openaiext
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.21
+signing_key: 
+specification_version: 4
+summary: Ruby OpenAI Extended
+test_files: []