ruby-openai 6.5.0 → 7.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f3db6f0c15b1015a875950a23ad157cb9f6f4eaed2005c35f75fd97197ee3dd6
-  data.tar.gz: e11f7020b2db2d627646c584feb7dfb2163f3bd8233860e5115ffe0f8d65c681
+  metadata.gz: 8334c2f0658ff33f39e96e8316b5c7122ca8810f5bfaca945c8d5f1add38b85a
+  data.tar.gz: b761ed842f7c27ba7f3e6e3137f6d60f2d51cb1a32f585989fd2b1992d256b46
 SHA512:
-  metadata.gz: 76100b527ed276b83190df15c1241be39d58288285e93caaeb20ca94c937082e1d19dd99b9ea69e1758352105e749e38940f1f0192b97c50fb18a8e81d321911
-  data.tar.gz: 425db82e5ae928dba3136351b697ac53335ffbce5afb81c98920efda2a0b4c600cf83a8273c8c627ad4b25a352ba76d2e77d88f00a48d4993dcbbc318077be53
+  metadata.gz: 7c53448def0a2a9849744a09c10f91fb4c16eb23fbf0d52be748574a9a96b05cb5641821c7728b9d95764cf50399f23c48bfdf3444d86ab80e65602e2264f6ba
+  data.tar.gz: 8806bbe03d2cde1b1fdfb691bcc2c4d803837faed6f001027135bdf9ed54a4bdf4eb01128c36d9d84b35622876ec087c494980e67b01a72a8ecb01040180cc72

data/.circleci/config.yml

@@ -8,7 +8,7 @@ jobs:
   rubocop:
     parallelism: 1
     docker:
-      - image: cimg/ruby:3.1-node
+      - image: cimg/ruby:3.2-node
     steps:
       - checkout
       - ruby/install-deps
@@ -43,3 +43,4 @@ workflows:
                 - cimg/ruby:3.0-node
                 - cimg/ruby:3.1-node
                 - cimg/ruby:3.2-node
+                - cimg/ruby:3.3-node

data/CHANGELOG.md

@@ -5,6 +5,35 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [7.0.0] - 2024-04-27
+
+### Added
+
+- Add support for Batches, thanks to [@simonx1](https://github.com/simonx1) for the PR!
+- Allow use of local LLMs like Ollama! Thanks to [@ThomasSevestre](https://github.com/ThomasSevestre)
+- Update to v2 of the Assistants beta & add documentation on streaming from an Assistant.
+- Add Assistants endpoint to create and run a thread in one go, thank you [@quocphien90](https://github.com/
+  quocphien90)
+- Add missing parameters (order, limit, etc) to Runs, RunSteps and Messages - thanks to [@shalecraig](https://github.com/shalecraig) and [@coezbek](https://github.com/coezbek)
+- Add missing Messages#list spec - thanks [@adammeghji](https://github.com/adammeghji)
+- Add Messages#modify to README - thanks to [@nas887](https://github.com/nas887)
+- Don't add the api_version (`/v1/`) to base_uris that already include it - thanks to [@kaiwren](https://github.com/kaiwren) for raising this issue
+- Allow passing a `StringIO` to Files#upload - thanks again to [@simonx1](https://github.com/simonx1)
+- Add Ruby 3.3 to CI
+
+### Security
+
+- [BREAKING] ruby-openai will no longer log out API errors by default - you can reenable by passing `log_errors: true` to your client. This will help to prevent leaking secrets to logs. Thanks to [@lalunamel](https://github.com/lalunamel) for this PR.
+
+### Removed
+
+- [BREAKING] Remove deprecated edits endpoint.
+
+### Fixed
+
+- Fix README DALL·E 3 error - thanks to [@clayton](https://github.com/clayton)
+- Fix README tool_calls error and add missing tool_choice info - thanks to [@Jbrito6492](https://github.com/Jbrito6492)
+
 ## [6.5.0] - 2024-03-31
 
 ### Added
@@ -67,13 +96,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - [BREAKING] Switch from legacy Finetunes to the new Fine-tune-jobs endpoints. Implemented by [@lancecarlson](https://github.com/lancecarlson)
 - [BREAKING] Remove deprecated Completions endpoints - use Chat instead.
 
-### Fix
+### Fixed
 
 - [BREAKING] Fix issue where :stream parameters were replaced by a boolean in the client application. Thanks to [@martinjaimem](https://github.com/martinjaimem), [@vickymadrid03](https://github.com/vickymadrid03) and [@nicastelo](https://github.com/nicastelo) for spotting and fixing this issue.
 
 ## [5.2.0] - 2023-10-30
 
-### Fix
+### Fixed
 
 - Added more spec-compliant SSE parsing: see here https://html.spec.whatwg.org/multipage/server-sent-events.html#event-stream-interpretation
 - Fixes issue where OpenAI or an intermediary returns only partial JSON per chunk of streamed data

data/Gemfile

@@ -6,7 +6,7 @@ gemspec
 gem "byebug", "~> 11.1.3"
 gem "dotenv", "~> 2.8.1"
 gem "rake", "~> 13.1"
-gem "rspec", "~> 3.12"
+gem "rspec", "~> 3.13"
 gem "rubocop", "~> 1.50.2"
 gem "vcr", "~> 6.1.0"
 gem "webmock", "~> 3.19.1"

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    ruby-openai (6.5.0)
+    ruby-openai (7.0.0)
       event_stream_parser (>= 0.3.0, < 2.0.0)
       faraday (>= 1)
       faraday-multipart (>= 1)
@@ -16,10 +16,10 @@ GEM
     byebug (11.1.3)
     crack (0.4.5)
       rexml
-    diff-lcs (1.5.0)
+    diff-lcs (1.5.1)
     dotenv (2.8.1)
     event_stream_parser (1.0.0)
-    faraday (2.7.12)
+    faraday (2.8.1)
       base64
       faraday-net_http (>= 2.0, < 3.1)
       ruby2_keywords (>= 0.0.4)
@@ -37,19 +37,19 @@ GEM
     rake (13.1.0)
     regexp_parser (2.8.0)
     rexml (3.2.6)
-    rspec (3.12.0)
-      rspec-core (~> 3.12.0)
-      rspec-expectations (~> 3.12.0)
-      rspec-mocks (~> 3.12.0)
-    rspec-core (3.12.0)
-      rspec-support (~> 3.12.0)
-    rspec-expectations (3.12.2)
+    rspec (3.13.0)
+      rspec-core (~> 3.13.0)
+      rspec-expectations (~> 3.13.0)
+      rspec-mocks (~> 3.13.0)
+    rspec-core (3.13.0)
+      rspec-support (~> 3.13.0)
+    rspec-expectations (3.13.0)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.12.0)
-    rspec-mocks (3.12.3)
+      rspec-support (~> 3.13.0)
+    rspec-mocks (3.13.0)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.12.0)
-    rspec-support (3.12.0)
+      rspec-support (~> 3.13.0)
+    rspec-support (3.13.1)
     rubocop (1.50.2)
       json (~> 2.3)
       parallel (~> 1.10)
@@ -78,7 +78,7 @@ DEPENDENCIES
   byebug (~> 11.1.3)
   dotenv (~> 2.8.1)
   rake (~> 13.1)
-  rspec (~> 3.12)
+  rspec (~> 3.13)
   rubocop (~> 1.50.2)
   ruby-openai!
   vcr (~> 6.1.0)

data/README.md

@@ -22,11 +22,13 @@ Stream text with GPT-4, transcribe and translate audio with Whisper, or create i
     - [With Config](#with-config)
       - [Custom timeout or base URI](#custom-timeout-or-base-uri)
       - [Extra Headers per Client](#extra-headers-per-client)
-      - [Verbose Logging](#verbose-logging)
+      - [Logging](#logging)
+        - [Errors](#errors)
+        - [Faraday middleware](#faraday-middleware)
       - [Azure](#azure)
+      - [Ollama](#ollama)
     - [Counting Tokens](#counting-tokens)
     - [Models](#models)
-      - [Examples](#examples)
     - [Chat](#chat)
       - [Streaming Chat](#streaming-chat)
       - [Vision](#vision)
@@ -34,6 +36,7 @@ Stream text with GPT-4, transcribe and translate audio with Whisper, or create i
     - [Functions](#functions)
     - [Edits](#edits)
     - [Embeddings](#embeddings)
+    - [Batches](#batches)
     - [Files](#files)
     - [Finetunes](#finetunes)
     - [Assistants](#assistants)
@@ -146,6 +149,7 @@ or when configuring the gem:
 ```ruby
 OpenAI.configure do |config|
     config.access_token = ENV.fetch("OPENAI_ACCESS_TOKEN")
+    config.log_errors = true # Optional
     config.organization_id = ENV.fetch("OPENAI_ORGANIZATION_ID") # Optional
     config.uri_base = "https://oai.hconeai.com/" # Optional
     config.request_timeout = 240 # Optional
@@ -166,7 +170,19 @@ client = OpenAI::Client.new(access_token: "access_token_goes_here")
 client.add_headers("X-Proxy-TTL" => "43200")
 ```
 
-#### Verbose Logging
+#### Logging
+
+##### Errors
+
+By default, `ruby-openai` does not log any `Faraday::Error`s encountered while executing a network request to avoid leaking data (e.g. 400s, 500s, SSL errors and more - see [here](https://www.rubydoc.info/github/lostisland/faraday/Faraday/Error) for a complete list of subclasses of `Faraday::Error` and what can cause them).
+
+If you would like to enable this functionality, you can set `log_errors` to `true` when configuring the client:
+
+```ruby
+  client = OpenAI::Client.new(log_errors: true)
+```
+
+##### Faraday middleware
 
 You can pass [Faraday middleware](https://lostisland.github.io/faraday/#/middleware/index) to the client in a block, eg. to enable verbose logging with Ruby's [Logger](https://ruby-doc.org/3.2.2/stdlibs/logger/Logger.html):
 
@@ -191,6 +207,38 @@ To use the [Azure OpenAI Service](https://learn.microsoft.com/en-us/azure/cognit
 
 where `AZURE_OPENAI_URI` is e.g. `https://custom-domain.openai.azure.com/openai/deployments/gpt-35-turbo`
 
+#### Ollama
+
+Ollama allows you to run open-source LLMs, such as Llama 3, locally. It [offers chat compatibility](https://github.com/ollama/ollama/blob/main/docs/openai.md) with the OpenAI API.
+
+You can download Ollama [here](https://ollama.com/). On macOS you can install and run Ollama like this:
+
+```bash
+brew install ollama
+ollama serve
+ollama pull llama3:latest # In new terminal tab.
+```
+
+Create a client using your Ollama server and the pulled model, and stream a conversation for free:
+
+```ruby
+client = OpenAI::Client.new(
+  uri_base: "http://localhost:11434"
+)
+
+client.chat(
+    parameters: {
+        model: "llama3", # Required.
+        messages: [{ role: "user", content: "Hello!"}], # Required.
+        temperature: 0.7,
+        stream: proc do |chunk, _bytesize|
+            print chunk.dig("choices", 0, "delta", "content")
+        end
+    })
+
+# => Hi! It's nice to meet you. Is there something I can help you with, or would you like to chat?
+```
+
 ### Counting Tokens
 
 OpenAI parses prompt text into [tokens](https://help.openai.com/en/articles/4936856-what-are-tokens-and-how-to-count-them), which are words or portions of words. (These tokens are unrelated to your API access_token.) Counting tokens can help you estimate your [costs](https://openai.com/pricing). It can also help you ensure your prompt text size is within the max-token limits of your model's context window, and choose an appropriate [`max_tokens`](https://platform.openai.com/docs/api-reference/chat/create#chat/create-max_tokens) completion parameter so your response will fit as well.
@@ -209,24 +257,9 @@ There are different models that can be used to generate text. For a full list an
 
 ```ruby
 client.models.list
-client.models.retrieve(id: "text-ada-001")
+client.models.retrieve(id: "gpt-3.5-turbo")
 ```
 
-#### Examples
-
-- [GPT-4 (limited beta)](https://platform.openai.com/docs/models/gpt-4)
-  - gpt-4 (uses current version)
-  - gpt-4-0314
-  - gpt-4-32k
-- [GPT-3.5](https://platform.openai.com/docs/models/gpt-3-5)
-  - gpt-3.5-turbo
-  - gpt-3.5-turbo-0301
-  - text-davinci-003
-- [GPT-3](https://platform.openai.com/docs/models/gpt-3)
-  - text-ada-001
-  - text-babbage-001
-  - text-curie-001
-
 ### Chat
 
 GPT is a model that can be used to generate text in a conversational style. You can use it to [generate a response](https://platform.openai.com/docs/api-reference/chat/create) to a sequence of [messages](https://platform.openai.com/docs/guides/chat/introduction):
@@ -338,9 +371,10 @@ You can stream it as well!
 
 ### Functions
 
-You can describe and pass in functions and the model will intelligently choose to output a JSON object containing arguments to call those them. For example, if you want the model to use your method `get_current_weather` to get the current weather in a given location:
+You can describe and pass in functions and the model will intelligently choose to output a JSON object containing arguments to call them - eg., to use your method `get_current_weather` to get the weather in a given location. Note that tool_choice is optional, but if you exclude it, the model will choose whether to use the function or not ([see here](https://platform.openai.com/docs/api-reference/chat/create#chat-create-tool_choice)).
 
 ```ruby
+
 def get_current_weather(location:, unit: "fahrenheit")
   # use a weather api to fetch weather
 end
@@ -348,7 +382,7 @@ end
 response =
   client.chat(
     parameters: {
-      model: "gpt-3.5-turbo-0613",
+      model: "gpt-3.5-turbo",
       messages: [
         {
           "role": "user",
@@ -378,16 +412,22 @@ response =
           },
         }
       ],
+      tool_choice: {
+        type: "function",
+        function: {
+          name: "get_current_weather"
+        }
+      }
     },
   )
 
 message = response.dig("choices", 0, "message")
 
 if message["role"] == "assistant" && message["tool_calls"]
-  function_name = message.dig("tool_calls", "function",  "name")
+  function_name = message.dig("tool_calls", 0, "function", "name")
   args =
     JSON.parse(
-      message.dig("tool_calls", "function", "arguments"),
+      message.dig("tool_calls", 0, "function", "arguments"),
       { symbolize_names: true },
     )
 
@@ -406,7 +446,7 @@ Hit the OpenAI API for a completion using other GPT-3 models:
 ```ruby
 response = client.completions(
     parameters: {
-        model: "text-davinci-001",
+        model: "gpt-3.5-turbo",
         prompt: "Once upon a time",
         max_tokens: 5
     })
@@ -414,22 +454,6 @@ puts response["choices"].map { |c| c["text"] }
 # => [", there lived a great"]
 ```
 
-### Edits
-
-Send a string and some instructions for what to do to the string:
-
-```ruby
-response = client.edits(
-    parameters: {
-        model: "text-davinci-edit-001",
-        input: "What day of the wek is it?",
-        instruction: "Fix the spelling mistakes"
-    }
-)
-puts response.dig("choices", 0, "text")
-# => What day of the week is it?
-```
-
 ### Embeddings
 
 You can use the embeddings endpoint to get a vector of numbers representing an input. You can then compare these vectors for different inputs to efficiently check how similar the inputs are.
@@ -446,6 +470,94 @@ puts response.dig("data", 0, "embedding")
 # => Vector representation of your embedding
 ```
 
+### Batches
+
+The Batches endpoint allows you to create and manage large batches of API requests to run asynchronously. Currently, only the `/v1/chat/completions` endpoint is supported for batches.
+
+To use the Batches endpoint, you need to first upload a JSONL file containing the batch requests using the Files endpoint. The file must be uploaded with the purpose set to `batch`. Each line in the JSONL file represents a single request and should have the following format:
+
+```json
+{
+  "custom_id": "request-1",
+  "method": "POST",
+  "url": "/v1/chat/completions",
+  "body": {
+    "model": "gpt-3.5-turbo",
+    "messages": [
+      { "role": "system", "content": "You are a helpful assistant." },
+      { "role": "user", "content": "What is 2+2?" }
+    ]
+  }
+}
+```
+
+Once you have uploaded the JSONL file, you can create a new batch by providing the file ID, endpoint, and completion window:
+
+```ruby
+response = client.batches.create(
+  parameters: {
+    input_file_id: "file-abc123",
+    endpoint: "/v1/chat/completions",
+    completion_window: "24h"
+  }
+)
+batch_id = response["id"]
+```
+
+You can retrieve information about a specific batch using its ID:
+
+```ruby
+batch = client.batches.retrieve(id: batch_id)
+```
+
+To cancel a batch that is in progress:
+
+```ruby
+client.batches.cancel(id: batch_id)
+```
+
+You can also list all the batches:
+
+```ruby
+client.batches.list
+```
+
+Once the batch["completed_at"] is present, you can fetch the output or error files:
+
+```ruby
+batch = client.batches.retrieve(id: batch_id)
+output_file_id = batch["output_file_id"]
+output_response = client.files.content(id: output_file_id)
+error_file_id = batch["error_file_id"]
+error_response = client.files.content(id: error_file_id)
+```
+
+These files are in JSONL format, with each line representing the output or error for a single request. The lines can be in any order:
+
+```json
+{
+  "id": "response-1",
+  "custom_id": "request-1",
+  "response": {
+    "id": "chatcmpl-abc123",
+    "object": "chat.completion",
+    "created": 1677858242,
+    "model": "gpt-3.5-turbo-0301",
+    "choices": [
+      {
+        "index": 0,
+        "message": {
+          "role": "assistant",
+          "content": "2+2 equals 4."
+        }
+      }
+    ]
+  }
+}
+```
+
+If a request fails with a non-HTTP error, the error object will contain more information about the cause of the failure.
+
 ### Files
 
 Put your data in a `.jsonl` file like this:
@@ -455,7 +567,7 @@ Put your data in a `.jsonl` file like this:
 {"prompt":"@lakers disappoint for a third straight night ->", "completion":" negative"}
 ```
 
-and pass the path to `client.files.upload` to upload it to OpenAI, and then interact with it:
+and pass the path (or a StringIO object) to `client.files.upload` to upload it to OpenAI, and then interact with it:
 
 ```ruby
 client.files.upload(parameters: { file: "path/to/sentiment.jsonl", purpose: "fine-tune" })
@@ -480,7 +592,7 @@ You can then use this file ID to create a fine tuning job:
 response = client.finetunes.create(
     parameters: {
     training_file: file_id,
-    model: "gpt-3.5-turbo-0613"
+    model: "gpt-3.5-turbo"
 })
 fine_tune_id = response["id"]
 ```
@@ -519,9 +631,9 @@ client.finetunes.list_events(id: fine_tune_id)
 
 ### Assistants
 
-Assistants can call models to interact with threads and use tools to perform tasks (see [Assistant Overview](https://platform.openai.com/docs/assistants/overview)).
+Assistants are stateful actors that can have many conversations and use tools to perform tasks (see [Assistant Overview](https://platform.openai.com/docs/assistants/overview)).
 
-To create a new assistant (see [API documentation](https://platform.openai.com/docs/api-reference/assistants/createAssistant)):
+To create a new assistant:
 
 ```ruby
 response = client.assistants.create(
@@ -605,17 +717,36 @@ client.messages.retrieve(thread_id: thread_id, id: message_id) # -> Fails after
 
 ### Runs
 
-To submit a thread to be evaluated with the model of an assistant, create a `Run` as follows (Note: This is one place where OpenAI will take your money):
+To submit a thread to be evaluated with the model of an assistant, create a `Run` as follows:
 
 ```ruby
 # Create run (will use instruction/model/tools from Assistant's definition)
 response = client.runs.create(thread_id: thread_id,
     parameters: {
-        assistant_id: assistant_id
+        assistant_id: assistant_id,
+        max_prompt_tokens: 256,
+        max_completion_tokens: 16
     })
 run_id = response['id']
+```
 
-# Retrieve/poll Run to observe status
+You can stream the message chunks as they come through:
+
+```ruby
+client.runs.create(thread_id: thread_id,
+    parameters: {
+        assistant_id: assistant_id,
+        max_prompt_tokens: 256,
+        max_completion_tokens: 16,
+        stream: proc do |chunk, _bytesize|
+          print chunk.dig("delta", "content", 0, "text", "value") if chunk["object"] == "thread.message.delta"
+        end
+    })
+```
+
+To get the status of a Run:
+
+```
 response = client.runs.retrieve(id: run_id, thread_id: thread_id)
 status = response['status']
 ```
@@ -624,23 +755,22 @@ The `status` response can include the following strings `queued`, `in_progress`,
 
 ```ruby
 while true do
-
     response = client.runs.retrieve(id: run_id, thread_id: thread_id)
     status = response['status']
 
     case status
     when 'queued', 'in_progress', 'cancelling'
-        puts 'Sleeping'
-        sleep 1 # Wait one second and poll again
+      puts 'Sleeping'
+      sleep 1 # Wait one second and poll again
     when 'completed'
-        break # Exit loop and report result to user
+      break # Exit loop and report result to user
     when 'requires_action'
-        # Handle tool calls (see below)
+      # Handle tool calls (see below)
     when 'cancelled', 'failed', 'expired'
-        puts response['last_error'].inspect
-        break # or `exit`
+      puts response['last_error'].inspect
+      break # or `exit`
     else
-        puts "Unknown status response: #{status}"
+      puts "Unknown status response: #{status}"
     end
 end
 ```
@@ -649,10 +779,10 @@ If the `status` response indicates that the `run` is `completed`, the associated
 
 ```ruby
 # Either retrieve all messages in bulk again, or...
-messages = client.messages.list(thread_id: thread_id) # Note: as of 2023-12-11 adding limit or order options isn't working, yet
+messages = client.messages.list(thread_id: thread_id, parameters: { order: 'asc' })
 
 # Alternatively retrieve the `run steps` for the run which link to the messages:
-run_steps = client.run_steps.list(thread_id: thread_id, run_id: run_id)
+run_steps = client.run_steps.list(thread_id: thread_id, run_id: run_id, parameters: { order: 'asc' })
 new_message_ids = run_steps['data'].filter_map { |step|
   if step['type'] == 'message_creation'
     step.dig('step_details', "message_creation", "message_id")
@@ -679,10 +809,33 @@ new_messages.each { |msg|
 }
 ```
 
-At any time you can list all runs which have been performed on a particular thread or are currently running (in descending/newest first order):
+You can also update the metadata on messages, including messages that come from the assistant.
 
 ```ruby
-client.runs.list(thread_id: thread_id)
+metadata = {
+  user_id: "abc123"
+}
+message = client.messages.modify(id: message_id, thread_id: thread_id, parameters: { metadata: metadata })
+```
+
+At any time you can list all runs which have been performed on a particular thread or are currently running:
+
+```ruby
+client.runs.list(thread_id: thread_id, parameters: { order: "asc", limit: 3 })
+```
+
+#### Create and Run
+
+You can also create a thread and run in one call like this:
+
+```ruby
+response = client.threads.create_and_run(
+    parameters: {
+        model: 'gpt-3.5-turbo',
+        messages: [{ role: 'user', content: "What's deep learning?"}]
+    })
+run_id = response['id']
+thread_id = response['thread_id']
 ```
 
 #### Runs involving function tools
@@ -746,7 +899,7 @@ puts response.dig("data", 0, "url")
 For DALL·E 3 the size of any generated images must be one of `1024x1024`, `1024x1792` or `1792x1024`. Additionally the quality of the image can be specified to either `standard` or `hd`.
 
 ```ruby
-response = client.images.generate(parameters: { prompt: "A springer spaniel cooking pasta wearing a hat of some sort", size: "1024x1792", quality: "standard" })
+response = client.images.generate(parameters: { prompt: "A springer spaniel cooking pasta wearing a hat of some sort", model: "dall-e-3", size: "1024x1792", quality: "standard" })
 puts response.dig("data", 0, "url")
 # => "https://oaidalleapiprodscus.blob.core.windows.net/private/org-Rf437IxKhh..."
 ```
@@ -845,7 +998,7 @@ HTTP errors can be caught like this:
 
 ```
   begin
-    OpenAI::Client.new.models.retrieve(id: "text-ada-001")
+    OpenAI::Client.new.models.retrieve(id: "gpt-3.5-turbo")
   rescue Faraday::Error => e
     raise "Got a Faraday error: #{e}"
   end

data/lib/openai/assistants.rb

@@ -1,7 +1,7 @@
 module OpenAI
   class Assistants
     def initialize(client:)
-      @client = client.beta(assistants: "v1")
+      @client = client.beta(assistants: "v2")
     end
 
     def list

data/lib/openai/batches.rb

@@ -0,0 +1,23 @@
+module OpenAI
+  class Batches
+    def initialize(client:)
+      @client = client.beta(assistants: "v1")
+    end
+
+    def list
+      @client.get(path: "/batches")
+    end
+
+    def retrieve(id:)
+      @client.get(path: "/batches/#{id}")
+    end
+
+    def create(parameters: {})
+      @client.json_post(path: "/batches", parameters: parameters)
+    end
+
+    def cancel(id:)
+      @client.post(path: "/batches/#{id}/cancel")
+    end
+  end
+end

data/lib/openai/client.rb

@@ -6,6 +6,7 @@ module OpenAI
       api_type
       api_version
       access_token
+      log_errors
       organization_id
       uri_base
       request_timeout
@@ -17,7 +18,10 @@ module OpenAI
       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))
+        instance_variable_set(
+          "@#{key}",
+          config[key].nil? ? OpenAI.configuration.send(key) : config[key]
+        )
       end
       @faraday_middleware = faraday_middleware
     end
@@ -26,10 +30,6 @@ module OpenAI
       json_post(path: "/chat/completions", parameters: parameters)
     end
 
-    def edits(parameters: {})
-      json_post(path: "/edits", parameters: parameters)
-    end
-
     def embeddings(parameters: {})
       json_post(path: "/embeddings", parameters: parameters)
     end
@@ -78,6 +78,10 @@ module OpenAI
       @run_steps ||= OpenAI::RunSteps.new(client: self)
     end
 
+    def batches
+      @batches ||= OpenAI::Batches.new(client: self)
+    end
+
     def moderations(parameters: {})
       json_post(path: "/moderations", parameters: parameters)
     end

data/lib/openai/files.rb

@@ -1,5 +1,11 @@
 module OpenAI
   class Files
+    PURPOSES = %w[
+      assistants
+      batch
+      fine-tune
+    ].freeze
+
     def initialize(client:)
       @client = client
     end
@@ -9,12 +15,17 @@ module OpenAI
     end
 
     def upload(parameters: {})
-      validate(file: parameters[:file]) if parameters[:file].include?(".jsonl")
+      file_input = parameters[:file]
+      file = prepare_file_input(file_input: file_input)
+
+      validate(file: file, purpose: parameters[:purpose], file_input: file_input)
 
       @client.multipart_post(
         path: "/files",
-        parameters: parameters.merge(file: File.open(parameters[:file]))
+        parameters: parameters.merge(file: file)
       )
+    ensure
+      file.close if file.is_a?(File)
     end
 
     def retrieve(id:)
@@ -31,12 +42,33 @@ module OpenAI
 
     private
 
-    def validate(file:)
-      File.open(file).each_line.with_index do |line, index|
+    def prepare_file_input(file_input:)
+      if file_input.is_a?(String)
+        File.open(file_input)
+      elsif file_input.respond_to?(:read) && file_input.respond_to?(:rewind)
+        file_input
+      else
+        raise ArgumentError, "Invalid file - must be a StringIO object or a path to a file."
+      end
+    end
+
+    def validate(file:, purpose:, file_input:)
+      raise ArgumentError, "`file` is required" if file.nil?
+      unless PURPOSES.include?(purpose)
+        raise ArgumentError, "`purpose` must be one of `#{PURPOSES.join(',')}`"
+      end
+
+      validate_jsonl(file: file) if file_input.is_a?(String) && file_input.end_with?(".jsonl")
+    end
+
+    def validate_jsonl(file:)
+      file.each_line.with_index do |line, index|
         JSON.parse(line)
       rescue JSON::ParserError => e
         raise JSON::ParserError, "#{e.message} - found on line #{index + 1} of #{file}"
       end
+    ensure
+      file.rewind
     end
   end
 end

data/lib/openai/http.rb

@@ -6,8 +6,8 @@ module OpenAI
   module HTTP
     include HTTPHeaders
 
-    def get(path:)
-      parse_jsonl(conn.get(uri(path: path)) do |req|
+    def get(path:, parameters: nil)
+      parse_jsonl(conn.get(uri(path: path), parameters) do |req|
         req.headers = headers
       end&.body)
     end
@@ -74,7 +74,7 @@ module OpenAI
       connection = Faraday.new do |f|
         f.options[:timeout] = @request_timeout
         f.request(:multipart) if multipart
-        f.use MiddlewareErrors
+        f.use MiddlewareErrors if @log_errors
         f.response :raise_error
         f.response :json
       end
@@ -88,6 +88,8 @@ module OpenAI
       if azure?
         base = File.join(@uri_base, path)
         "#{base}?api-version=#{@api_version}"
+      elsif @uri_base.include?(@api_version)
+        File.join(@uri_base, path)
       else
         File.join(@uri_base, @api_version, path)
       end
@@ -97,10 +99,14 @@ module OpenAI
       parameters&.transform_values do |value|
         next value unless value.respond_to?(:close) # File or IO object.
 
+        # Faraday::UploadIO does not require a path, so we will pass it
+        # only if it is available. This allows StringIO objects to be
+        # passed in as well.
+        path = value.respond_to?(:path) ? value.path : nil
         # 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)
+        Faraday::UploadIO.new(value, "", path)
       end
     end
 

data/lib/openai/messages.rb

@@ -4,8 +4,8 @@ module OpenAI
       @client = client.beta(assistants: "v1")
     end
 
-    def list(thread_id:)
-      @client.get(path: "/threads/#{thread_id}/messages")
+    def list(thread_id:, parameters: {})
+      @client.get(path: "/threads/#{thread_id}/messages", parameters: parameters)
     end
 
     def retrieve(thread_id:, id:)

data/lib/openai/run_steps.rb

@@ -4,8 +4,8 @@ module OpenAI
       @client = client.beta(assistants: "v1")
     end
 
-    def list(thread_id:, run_id:)
-      @client.get(path: "/threads/#{thread_id}/runs/#{run_id}/steps")
+    def list(thread_id:, run_id:, parameters: {})
+      @client.get(path: "/threads/#{thread_id}/runs/#{run_id}/steps", parameters: parameters)
     end
 
     def retrieve(thread_id:, run_id:, id:)

data/lib/openai/runs.rb

@@ -4,8 +4,8 @@ module OpenAI
       @client = client.beta(assistants: "v1")
     end
 
-    def list(thread_id:)
-      @client.get(path: "/threads/#{thread_id}/runs")
+    def list(thread_id:, parameters: {})
+      @client.get(path: "/threads/#{thread_id}/runs", parameters: parameters)
     end
 
     def retrieve(thread_id:, id:)
@@ -24,6 +24,10 @@ module OpenAI
       @client.post(path: "/threads/#{thread_id}/runs/#{id}/cancel")
     end
 
+    def create_thread_and_run(parameters: {})
+      @client.json_post(path: "/threads/runs", parameters: parameters)
+    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)

data/lib/openai/version.rb

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

data/lib/openai.rb

@@ -14,6 +14,7 @@ require_relative "openai/runs"
 require_relative "openai/run_steps"
 require_relative "openai/audio"
 require_relative "openai/version"
+require_relative "openai/batches"
 
 module OpenAI
   class Error < StandardError; end
@@ -36,30 +37,30 @@ module OpenAI
   end
 
   class Configuration
-    attr_writer :access_token
-    attr_accessor :api_type, :api_version, :organization_id, :uri_base, :request_timeout,
+    attr_accessor :access_token,
+                  :api_type,
+                  :api_version,
+                  :log_errors,
+                  :organization_id,
+                  :uri_base,
+                  :request_timeout,
                   :extra_headers
 
     DEFAULT_API_VERSION = "v1".freeze
     DEFAULT_URI_BASE = "https://api.openai.com/".freeze
     DEFAULT_REQUEST_TIMEOUT = 120
+    DEFAULT_LOG_ERRORS = false
 
     def initialize
       @access_token = nil
       @api_type = nil
       @api_version = DEFAULT_API_VERSION
+      @log_errors = DEFAULT_LOG_ERRORS
       @organization_id = nil
       @uri_base = DEFAULT_URI_BASE
       @request_timeout = DEFAULT_REQUEST_TIMEOUT
       @extra_headers = {}
     end
-
-    def access_token
-      return @access_token if @access_token
-
-      error_text = "OpenAI access token missing! See https://github.com/alexrudall/ruby-openai#usage"
-      raise ConfigurationError, error_text
-    end
   end
 
   class << self

data/ruby-openai.gemspec

@@ -6,7 +6,7 @@ Gem::Specification.new do |spec|
   spec.authors       = ["Alex"]
   spec.email         = ["alexrudall@users.noreply.github.com"]
 
-  spec.summary       = "OpenAI API + Ruby! 🤖🩵"
+  spec.summary       = "OpenAI API + Ruby! 🤖❤️"
   spec.homepage      = "https://github.com/alexrudall/ruby-openai"
   spec.license       = "MIT"
   spec.required_ruby_version = Gem::Requirement.new(">= 2.6.0")

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-openai
 version: !ruby/object:Gem::Version
-  version: 6.5.0
+  version: 7.0.0
 platform: ruby
 authors:
 - Alex
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-03-31 00:00:00.000000000 Z
+date: 2024-04-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: event_stream_parser
@@ -89,6 +89,7 @@ files:
 - lib/openai.rb
 - lib/openai/assistants.rb
 - lib/openai/audio.rb
+- lib/openai/batches.rb
 - lib/openai/client.rb
 - lib/openai/compatibility.rb
 - lib/openai/files.rb
@@ -129,8 +130,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.22
+rubygems_version: 3.5.9
 signing_key:
 specification_version: 4
-summary: "OpenAI API + Ruby! \U0001F916\U0001FA75"
+summary: "OpenAI API + Ruby! \U0001F916❤️"
 test_files: []