ruby-openai 3.6.0 → 6.5.0

data/Rakefile

@@ -1,6 +1,19 @@
 require "bundler/gem_tasks"
 require "rspec/core/rake_task"
+require "rubocop/rake_task"
 
 RSpec::Core::RakeTask.new(:spec)
 
-task default: :spec
+task :default do
+  Rake::Task["test"].invoke
+  Rake::Task["lint"].invoke
+end
+
+task :test do
+  Rake::Task["spec"].invoke
+end
+
+task :lint do
+  RuboCop::RakeTask.new(:rubocop)
+  Rake::Task["rubocop"].invoke
+end

data/lib/openai/assistants.rb

@@ -0,0 +1,27 @@
+module OpenAI
+  class Assistants
+    def initialize(client:)
+      @client = client.beta(assistants: "v1")
+    end
+
+    def list
+      @client.get(path: "/assistants")
+    end
+
+    def retrieve(id:)
+      @client.get(path: "/assistants/#{id}")
+    end
+
+    def create(parameters: {})
+      @client.json_post(path: "/assistants", parameters: parameters)
+    end
+
+    def modify(id:, parameters: {})
+      @client.json_post(path: "/assistants/#{id}", parameters: parameters)
+    end
+
+    def delete(id:)
+      @client.delete(path: "/assistants/#{id}")
+    end
+  end
+end

data/lib/openai/audio.rb

@@ -0,0 +1,19 @@
+module OpenAI
+  class Audio
+    def initialize(client:)
+      @client = client
+    end
+
+    def transcribe(parameters: {})
+      @client.multipart_post(path: "/audio/transcriptions", parameters: parameters)
+    end
+
+    def translate(parameters: {})
+      @client.multipart_post(path: "/audio/translations", parameters: parameters)
+    end
+
+    def speech(parameters: {})
+      @client.json_post(path: "/audio/speech", parameters: parameters)
+    end
+  end
+end

data/lib/openai/client.rb

@@ -1,105 +1,95 @@
 module OpenAI
   class Client
-    URI_BASE = "https://api.openai.com/".freeze
-
-    def initialize(access_token: nil, organization_id: nil, request_timeout: nil)
-      OpenAI.configuration.access_token = access_token if access_token
-      OpenAI.configuration.organization_id = organization_id if organization_id
-      OpenAI.configuration.request_timeout = request_timeout if request_timeout
+    include OpenAI::HTTP
+
+    CONFIG_KEYS = %i[
+      api_type
+      api_version
+      access_token
+      organization_id
+      uri_base
+      request_timeout
+      extra_headers
+    ].freeze
+    attr_reader *CONFIG_KEYS, :faraday_middleware
+
+    def initialize(config = {}, &faraday_middleware)
+      CONFIG_KEYS.each do |key|
+        # Set instance variables like api_type & access_token. Fall back to global config
+        # if not present.
+        instance_variable_set("@#{key}", config[key] || OpenAI.configuration.send(key))
+      end
+      @faraday_middleware = faraday_middleware
     end
 
     def chat(parameters: {})
-      OpenAI::Client.json_post(path: "/chat/completions", parameters: parameters)
-    end
-
-    def completions(parameters: {})
-      OpenAI::Client.json_post(path: "/completions", parameters: parameters)
+      json_post(path: "/chat/completions", parameters: parameters)
     end
 
     def edits(parameters: {})
-      OpenAI::Client.json_post(path: "/edits", parameters: parameters)
+      json_post(path: "/edits", parameters: parameters)
     end
 
     def embeddings(parameters: {})
-      OpenAI::Client.json_post(path: "/embeddings", parameters: parameters)
+      json_post(path: "/embeddings", parameters: parameters)
     end
 
-    def files
-      @files ||= OpenAI::Files.new
+    def completions(parameters: {})
+      json_post(path: "/completions", parameters: parameters)
     end
 
-    def finetunes
-      @finetunes ||= OpenAI::Finetunes.new
+    def audio
+      @audio ||= OpenAI::Audio.new(client: self)
     end
 
-    def images
-      @images ||= OpenAI::Images.new
+    def files
+      @files ||= OpenAI::Files.new(client: self)
     end
 
-    def models
-      @models ||= OpenAI::Models.new
+    def finetunes
+      @finetunes ||= OpenAI::Finetunes.new(client: self)
     end
 
-    def moderations(parameters: {})
-      OpenAI::Client.json_post(path: "/moderations", parameters: parameters)
+    def images
+      @images ||= OpenAI::Images.new(client: self)
     end
 
-    def transcribe(parameters: {})
-      OpenAI::Client.multipart_post(path: "/audio/transcriptions", parameters: parameters)
+    def models
+      @models ||= OpenAI::Models.new(client: self)
     end
 
-    def translate(parameters: {})
-      OpenAI::Client.multipart_post(path: "/audio/translations", parameters: parameters)
+    def assistants
+      @assistants ||= OpenAI::Assistants.new(client: self)
     end
 
-    def self.get(path:)
-      HTTParty.get(
-        uri(path: path),
-        headers: headers,
-        timeout: request_timeout
-      )
+    def threads
+      @threads ||= OpenAI::Threads.new(client: self)
     end
 
-    def self.json_post(path:, parameters:)
-      HTTParty.post(
-        uri(path: path),
-        headers: headers,
-        body: parameters&.to_json,
-        timeout: request_timeout
-      )
+    def messages
+      @messages ||= OpenAI::Messages.new(client: self)
     end
 
-    def self.multipart_post(path:, parameters: nil)
-      HTTParty.post(
-        uri(path: path),
-        headers: headers.merge({ "Content-Type" => "multipart/form-data" }),
-        body: parameters,
-        timeout: request_timeout
-      )
+    def runs
+      @runs ||= OpenAI::Runs.new(client: self)
     end
 
-    def self.delete(path:)
-      HTTParty.delete(
-        uri(path: path),
-        headers: headers,
-        timeout: request_timeout
-      )
+    def run_steps
+      @run_steps ||= OpenAI::RunSteps.new(client: self)
     end
 
-    private_class_method def self.uri(path:)
-      URI_BASE + OpenAI.configuration.api_version + path
+    def moderations(parameters: {})
+      json_post(path: "/moderations", parameters: parameters)
     end
 
-    private_class_method def self.headers
-      {
-        "Content-Type" => "application/json",
-        "Authorization" => "Bearer #{OpenAI.configuration.access_token}",
-        "OpenAI-Organization" => OpenAI.configuration.organization_id
-      }
+    def azure?
+      @api_type&.to_sym == :azure
     end
 
-    private_class_method def self.request_timeout
-      OpenAI.configuration.request_timeout
+    def beta(apis)
+      dup.tap do |client|
+        client.add_headers("OpenAI-Beta": apis.map { |k, v| "#{k}=#{v}" }.join(";"))
+      end
     end
   end
 end

data/lib/openai/compatibility.rb

@@ -5,5 +5,6 @@ module Ruby
     Error = ::OpenAI::Error
     ConfigurationError = ::OpenAI::ConfigurationError
     Configuration = ::OpenAI::Configuration
+    MiddlewareErrors = ::OpenAI::MiddlewareErrors
   end
 end

data/lib/openai/files.rb

@@ -1,33 +1,32 @@
 module OpenAI
   class Files
-    def initialize(access_token: nil, organization_id: nil)
-      OpenAI.configuration.access_token = access_token if access_token
-      OpenAI.configuration.organization_id = organization_id if organization_id
+    def initialize(client:)
+      @client = client
     end
 
     def list
-      OpenAI::Client.get(path: "/files")
+      @client.get(path: "/files")
     end
 
     def upload(parameters: {})
-      validate(file: parameters[:file])
+      validate(file: parameters[:file]) if parameters[:file].include?(".jsonl")
 
-      OpenAI::Client.multipart_post(
+      @client.multipart_post(
         path: "/files",
         parameters: parameters.merge(file: File.open(parameters[:file]))
       )
     end
 
     def retrieve(id:)
-      OpenAI::Client.get(path: "/files/#{id}")
+      @client.get(path: "/files/#{id}")
     end
 
     def content(id:)
-      OpenAI::Client.get(path: "/files/#{id}/content")
+      @client.get(path: "/files/#{id}/content")
     end
 
     def delete(id:)
-      OpenAI::Client.delete(path: "/files/#{id}")
+      @client.delete(path: "/files/#{id}")
     end
 
     private

data/lib/openai/finetunes.rb

@@ -1,36 +1,27 @@
 module OpenAI
   class Finetunes
-    def initialize(access_token: nil, organization_id: nil)
-      OpenAI.configuration.access_token = access_token if access_token
-      OpenAI.configuration.organization_id = organization_id if organization_id
+    def initialize(client:)
+      @client = client
     end
 
     def list
-      OpenAI::Client.get(path: "/fine-tunes")
+      @client.get(path: "/fine_tuning/jobs")
     end
 
     def create(parameters: {})
-      OpenAI::Client.json_post(path: "/fine-tunes", parameters: parameters)
+      @client.json_post(path: "/fine_tuning/jobs", parameters: parameters)
     end
 
     def retrieve(id:)
-      OpenAI::Client.get(path: "/fine-tunes/#{id}")
+      @client.get(path: "/fine_tuning/jobs/#{id}")
     end
 
     def cancel(id:)
-      OpenAI::Client.multipart_post(path: "/fine-tunes/#{id}/cancel")
+      @client.json_post(path: "/fine_tuning/jobs/#{id}/cancel", parameters: {})
     end
 
-    def events(id:)
-      OpenAI::Client.get(path: "/fine-tunes/#{id}/events")
-    end
-
-    def delete(fine_tuned_model:)
-      if fine_tuned_model.start_with?("ft-")
-        raise ArgumentError, "Please give a fine_tuned_model name, not a fine-tune ID"
-      end
-
-      OpenAI::Client.delete(path: "/models/#{fine_tuned_model}")
+    def list_events(id:)
+      @client.get(path: "/fine_tuning/jobs/#{id}/events")
     end
   end
 end

data/lib/openai/http.rb

@@ -0,0 +1,127 @@
+require "event_stream_parser"
+
+require_relative "http_headers"
+
+module OpenAI
+  module HTTP
+    include HTTPHeaders
+
+    def get(path:)
+      parse_jsonl(conn.get(uri(path: path)) do |req|
+        req.headers = headers
+      end&.body)
+    end
+
+    def post(path:)
+      parse_jsonl(conn.post(uri(path: path)) do |req|
+        req.headers = headers
+      end&.body)
+    end
+
+    def json_post(path:, parameters:)
+      conn.post(uri(path: path)) do |req|
+        configure_json_post_request(req, parameters)
+      end&.body
+    end
+
+    def multipart_post(path:, parameters: nil)
+      conn(multipart: true).post(uri(path: path)) do |req|
+        req.headers = headers.merge({ "Content-Type" => "multipart/form-data" })
+        req.body = multipart_parameters(parameters)
+      end&.body
+    end
+
+    def delete(path:)
+      conn.delete(uri(path: path)) do |req|
+        req.headers = headers
+      end&.body
+    end
+
+    private
+
+    def parse_jsonl(response)
+      return unless response
+      return response unless response.is_a?(String)
+
+      # Convert a multiline string of JSON objects to a JSON array.
+      response = response.gsub("}\n{", "},{").prepend("[").concat("]")
+
+      JSON.parse(response)
+    end
+
+    # Given a proc, returns an outer proc that can be used to iterate over a JSON stream of chunks.
+    # For each chunk, the inner user_proc is called giving it the JSON object. The JSON object could
+    # be a data object or an error object as described in the OpenAI API documentation.
+    #
+    # @param user_proc [Proc] The inner proc to call for each JSON object in the chunk.
+    # @return [Proc] An outer proc that iterates over a raw stream, converting it to JSON.
+    def to_json_stream(user_proc:)
+      parser = EventStreamParser::Parser.new
+
+      proc do |chunk, _bytes, env|
+        if env && env.status != 200
+          raise_error = Faraday::Response::RaiseError.new
+          raise_error.on_complete(env.merge(body: try_parse_json(chunk)))
+        end
+
+        parser.feed(chunk) do |_type, data|
+          user_proc.call(JSON.parse(data)) unless data == "[DONE]"
+        end
+      end
+    end
+
+    def conn(multipart: false)
+      connection = Faraday.new do |f|
+        f.options[:timeout] = @request_timeout
+        f.request(:multipart) if multipart
+        f.use MiddlewareErrors
+        f.response :raise_error
+        f.response :json
+      end
+
+      @faraday_middleware&.call(connection)
+
+      connection
+    end
+
+    def uri(path:)
+      if azure?
+        base = File.join(@uri_base, path)
+        "#{base}?api-version=#{@api_version}"
+      else
+        File.join(@uri_base, @api_version, path)
+      end
+    end
+
+    def multipart_parameters(parameters)
+      parameters&.transform_values do |value|
+        next value unless value.respond_to?(:close) # File or IO object.
+
+        # Doesn't seem like OpenAI needs mime_type yet, so not worth
+        # the library to figure this out. Hence the empty string
+        # as the second argument.
+        Faraday::UploadIO.new(value, "", value.path)
+      end
+    end
+
+    def configure_json_post_request(req, parameters)
+      req_parameters = parameters.dup
+
+      if parameters[:stream].respond_to?(:call)
+        req.options.on_data = to_json_stream(user_proc: parameters[:stream])
+        req_parameters[:stream] = true # Necessary to tell OpenAI to stream.
+      elsif parameters[:stream]
+        raise ArgumentError, "The stream parameter must be a Proc or have a #call method"
+      end
+
+      req.headers = headers
+      req.body = req_parameters.to_json
+    end
+
+    def try_parse_json(maybe_json)
+      JSON.parse(maybe_json)
+    rescue JSON::ParserError
+      maybe_json
+    end
+  end
+end

data/lib/openai/http_headers.rb

@@ -0,0 +1,36 @@
+module OpenAI
+  module HTTPHeaders
+    def add_headers(headers)
+      @extra_headers = extra_headers.merge(headers.transform_keys(&:to_s))
+    end
+
+    private
+
+    def headers
+      if azure?
+        azure_headers
+      else
+        openai_headers
+      end.merge(extra_headers)
+    end
+
+    def openai_headers
+      {
+        "Content-Type" => "application/json",
+        "Authorization" => "Bearer #{@access_token}",
+        "OpenAI-Organization" => @organization_id
+      }
+    end
+
+    def azure_headers
+      {
+        "Content-Type" => "application/json",
+        "api-key" => @access_token
+      }
+    end
+
+    def extra_headers
+      @extra_headers ||= {}
+    end
+  end
+end

data/lib/openai/images.rb

@@ -1,20 +1,19 @@
 module OpenAI
   class Images
-    def initialize(access_token: nil, organization_id: nil)
-      OpenAI.configuration.access_token = access_token if access_token
-      OpenAI.configuration.organization_id = organization_id if organization_id
+    def initialize(client: nil)
+      @client = client
     end
 
     def generate(parameters: {})
-      OpenAI::Client.json_post(path: "/images/generations", parameters: parameters)
+      @client.json_post(path: "/images/generations", parameters: parameters)
     end
 
     def edit(parameters: {})
-      OpenAI::Client.multipart_post(path: "/images/edits", parameters: open_files(parameters))
+      @client.multipart_post(path: "/images/edits", parameters: open_files(parameters))
     end
 
     def variations(parameters: {})
-      OpenAI::Client.multipart_post(path: "/images/variations", parameters: open_files(parameters))
+      @client.multipart_post(path: "/images/variations", parameters: open_files(parameters))
     end
 
     private

data/lib/openai/messages.rb

@@ -0,0 +1,23 @@
+module OpenAI
+  class Messages
+    def initialize(client:)
+      @client = client.beta(assistants: "v1")
+    end
+
+    def list(thread_id:)
+      @client.get(path: "/threads/#{thread_id}/messages")
+    end
+
+    def retrieve(thread_id:, id:)
+      @client.get(path: "/threads/#{thread_id}/messages/#{id}")
+    end
+
+    def create(thread_id:, parameters: {})
+      @client.json_post(path: "/threads/#{thread_id}/messages", parameters: parameters)
+    end
+
+    def modify(id:, thread_id:, parameters: {})
+      @client.json_post(path: "/threads/#{thread_id}/messages/#{id}", parameters: parameters)
+    end
+  end
+end

data/lib/openai/models.rb

@@ -1,16 +1,15 @@
 module OpenAI
   class Models
-    def initialize(access_token: nil, organization_id: nil)
-      OpenAI.configuration.access_token = access_token if access_token
-      OpenAI.configuration.organization_id = organization_id if organization_id
+    def initialize(client:)
+      @client = client
     end
 
     def list
-      OpenAI::Client.get(path: "/models")
+      @client.get(path: "/models")
     end
 
     def retrieve(id:)
-      OpenAI::Client.get(path: "/models/#{id}")
+      @client.get(path: "/models/#{id}")
     end
   end
 end

data/lib/openai/run_steps.rb

@@ -0,0 +1,15 @@
+module OpenAI
+  class RunSteps
+    def initialize(client:)
+      @client = client.beta(assistants: "v1")
+    end
+
+    def list(thread_id:, run_id:)
+      @client.get(path: "/threads/#{thread_id}/runs/#{run_id}/steps")
+    end
+
+    def retrieve(thread_id:, run_id:, id:)
+      @client.get(path: "/threads/#{thread_id}/runs/#{run_id}/steps/#{id}")
+    end
+  end
+end

data/lib/openai/runs.rb

@@ -0,0 +1,32 @@
+module OpenAI
+  class Runs
+    def initialize(client:)
+      @client = client.beta(assistants: "v1")
+    end
+
+    def list(thread_id:)
+      @client.get(path: "/threads/#{thread_id}/runs")
+    end
+
+    def retrieve(thread_id:, id:)
+      @client.get(path: "/threads/#{thread_id}/runs/#{id}")
+    end
+
+    def create(thread_id:, parameters: {})
+      @client.json_post(path: "/threads/#{thread_id}/runs", parameters: parameters)
+    end
+
+    def modify(id:, thread_id:, parameters: {})
+      @client.json_post(path: "/threads/#{thread_id}/runs/#{id}", parameters: parameters)
+    end
+
+    def cancel(id:, thread_id:)
+      @client.post(path: "/threads/#{thread_id}/runs/#{id}/cancel")
+    end
+
+    def submit_tool_outputs(thread_id:, run_id:, parameters: {})
+      @client.json_post(path: "/threads/#{thread_id}/runs/#{run_id}/submit_tool_outputs",
+                        parameters: parameters)
+    end
+  end
+end

data/lib/openai/threads.rb

@@ -0,0 +1,23 @@
+module OpenAI
+  class Threads
+    def initialize(client:)
+      @client = client.beta(assistants: "v1")
+    end
+
+    def retrieve(id:)
+      @client.get(path: "/threads/#{id}")
+    end
+
+    def create(parameters: {})
+      @client.json_post(path: "/threads", parameters: parameters)
+    end
+
+    def modify(id:, parameters: {})
+      @client.json_post(path: "/threads/#{id}", parameters: parameters)
+    end
+
+    def delete(id:)
+      @client.delete(path: "/threads/#{id}")
+    end
+  end
+end

data/lib/openai/version.rb

@@ -1,3 +1,3 @@
 module OpenAI
-  VERSION = "3.6.0".freeze
+  VERSION = "6.5.0".freeze
 end