ruby-openai 7.4.0 → 8.3.0

data/README.md

@@ -1,22 +1,40 @@
 # Ruby OpenAI
+
 [![Gem Version](https://img.shields.io/gem/v/ruby-openai.svg)](https://rubygems.org/gems/ruby-openai)
 [![GitHub license](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/alexrudall/ruby-openai/blob/main/LICENSE.txt)
 [![CircleCI Build Status](https://circleci.com/gh/alexrudall/ruby-openai.svg?style=shield)](https://circleci.com/gh/alexrudall/ruby-openai)
 
 Use the [OpenAI API](https://openai.com/blog/openai-api/) with Ruby! 🤖❤️
 
-Stream text with GPT-4, transcribe and translate audio with Whisper, or create images with DALL·E...
+Stream GPT-5 chats with the Responses API, initiate Realtime WebRTC conversations, and much more...
+
+**Sponsors**
+
+<table>
+<tr>
+<td width="300" align="center" valign="top">
+
+[<img src="https://github.com/user-attachments/assets/b97e036d-3f22-4116-be97-8f8d1c432a4f" alt="InferToGo logo: man in suit falling, black and white" width="300" height="300">](https://infertogo.com/?utm_source=ruby-openai)
+
+<sub>_[InferToGo](https://infertogo.com/?utm_source=ruby-openai) - The inference addon for your PaaS application._</sub>
+
+</td>
+<td width="300" align="center" valign="top">
+
+[<img src="https://github.com/user-attachments/assets/3feb834c-2721-404c-a64d-02104ed4aba7" alt="SerpApi logo: Purple rounded square with 4 connected white holes" width="300" height="300">](https://serpapi.com/?utm_source=ruby-openai)
 
-💥 Click [subscribe now](https://mailchi.mp/8c7b574726a9/ruby-openai) to hear first about new releases in the Rails AI newsletter!
+<sub>_[SerpApi - Search API](https://serpapi.com/?utm_source=ruby-openai) - Enhance your LLM's knowledge with data from search engines like Google and Bing using our simple API._</sub>
 
-[![RailsAI Newsletter](https://github.com/user-attachments/assets/737cbb99-6029-42b8-9f22-a106725a4b1f)](https://mailchi.mp/8c7b574726a9/ruby-openai)
+</td>
+</tr>
+</table>
 
-[🎮 Ruby AI Builders Discord](https://discord.gg/k4Uc224xVD) | [🐦 X](https://x.com/alexrudall) | [🧠 Anthropic Gem](https://github.com/alexrudall/anthropic) | [🚂 Midjourney Gem](https://github.com/alexrudall/midjourney)
+[🎮 Ruby AI Builders Discord](https://discord.gg/k4Uc224xVD) | [🐦 X](https://x.com/alexrudall) | [🧠 Anthropic Gem](https://github.com/alexrudall/anthropic) | [🚂 Midjourney Gem](https://github.com/alexrudall/midjourney) |  [♥️ Thanks to all sponsors!](https://github.com/sponsors/alexrudall)
 
 ## Contents
 
 - [Ruby OpenAI](#ruby-openai)
-- [Table of Contents](#table-of-contents)
+  - [Contents](#contents)
   - [Installation](#installation)
     - [Bundler](#bundler)
     - [Gem install](#gem-install)
@@ -29,14 +47,24 @@ Stream text with GPT-4, transcribe and translate audio with Whisper, or create i
         - [Errors](#errors)
         - [Faraday middleware](#faraday-middleware)
       - [Azure](#azure)
+      - [Deepseek](#deepseek)
       - [Ollama](#ollama)
       - [Groq](#groq)
+      - [Gemini](#gemini)
     - [Counting Tokens](#counting-tokens)
     - [Models](#models)
     - [Chat](#chat)
       - [Streaming Chat](#streaming-chat)
       - [Vision](#vision)
       - [JSON Mode](#json-mode)
+    - [Responses API](#responses-api)
+      - [Create a Response](#create-a-response)
+      - [Follow-up Messages](#follow-up-messages)
+      - [Tool Calls](#tool-calls)
+      - [Streaming](#streaming)
+      - [Retrieve a Response](#retrieve-a-response)
+      - [Delete a Response](#delete-a-response)
+      - [List Input Items](#list-input-items)
     - [Functions](#functions)
     - [Completions](#completions)
     - [Embeddings](#embeddings)
@@ -49,6 +77,7 @@ Stream text with GPT-4, transcribe and translate audio with Whisper, or create i
     - [Vector Store Files](#vector-store-files)
     - [Vector Store File Batches](#vector-store-file-batches)
     - [Assistants](#assistants)
+    - [Conversations](#conversations)
     - [Threads and Messages](#threads-and-messages)
     - [Runs](#runs)
       - [Create and Run](#create-and-run)
@@ -65,9 +94,11 @@ Stream text with GPT-4, transcribe and translate audio with Whisper, or create i
       - [Translate](#translate)
       - [Transcribe](#transcribe)
       - [Speech](#speech)
+    - [Real-Time](#real-time)
     - [Usage](#usage)
     - [Errors](#errors-1)
   - [Development](#development)
+    - [To check for deprecations](#to-check-for-deprecations)
   - [Release](#release)
   - [Contributing](#contributing)
   - [License](#license)
@@ -86,7 +117,7 @@ gem "ruby-openai"
 And then execute:
 
 ```bash
-$ bundle install
+bundle install
 ```
 
 ### Gem install
@@ -94,7 +125,7 @@ $ bundle install
 Or install with:
 
 ```bash
-$ gem install ruby-openai
+gem install ruby-openai
 ```
 
 and require with:
@@ -205,7 +236,9 @@ 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):
+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):
 
 ```ruby
 client = OpenAI::Client.new do |f|
@@ -213,6 +246,13 @@ client = OpenAI::Client.new do |f|
 end
 ```
 
+- To add a web debugging proxy like [Charles](https://www.charlesproxy.com/documentation/welcome/):
+
+```ruby
+  client = OpenAI::Client.new do |f|
+    f.proxy = { uri: "http://localhost:8888" }
+  end
+```
 #### Azure
 
 To use the [Azure OpenAI Service](https://learn.microsoft.com/en-us/azure/cognitive-services/openai/) API, you can configure the gem like this:
@@ -228,6 +268,28 @@ end
 
 where `AZURE_OPENAI_URI` is e.g. `https://custom-domain.openai.azure.com/openai/deployments/gpt-35-turbo`
 
+#### Deepseek
+
+[Deepseek](https://api-docs.deepseek.com/) is compatible with the OpenAI chat API. Get an access token from [here](https://platform.deepseek.com/api_keys), then:
+
+```ruby
+client = OpenAI::Client.new(
+  access_token: "deepseek_access_token_goes_here",
+  uri_base: "https://api.deepseek.com/"
+)
+
+client.chat(
+  parameters: {
+    model: "deepseek-chat", # Required.
+    messages: [{ role: "user", content: "Hello!"}], # Required.
+    temperature: 0.7,
+    stream: proc do |chunk, _event|
+     print chunk.dig("choices", 0, "delta", "content")
+    end
+  }
+)
+```
+
 #### 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.
@@ -252,7 +314,7 @@ client.chat(
     model: "llama3", # Required.
     messages: [{ role: "user", content: "Hello!"}], # Required.
     temperature: 0.7,
-    stream: proc do |chunk, _bytesize|
+    stream: proc do |chunk, _event|
       print chunk.dig("choices", 0, "delta", "content")
     end
   }
@@ -276,11 +338,35 @@ client.chat(
     model: "llama3-8b-8192", # Required.
     messages: [{ role: "user", content: "Hello!"}], # Required.
     temperature: 0.7,
+    stream: proc do |chunk, _event|
+     print chunk.dig("choices", 0, "delta", "content")
+    end
+  }
+)
+```
+
+#### Gemini
+
+[Gemini API Chat](https://ai.google.dev/gemini-api/docs/openai) is also broadly compatible with the OpenAI API, and [currently in beta](https://ai.google.dev/gemini-api/docs/openai#current-limitations). Get an access token from [here](https://aistudio.google.com/app/apikey), then:
+
+```ruby
+client = OpenAI::Client.new(
+  access_token: "gemini_access_token_goes_here",
+  uri_base: "https://generativelanguage.googleapis.com/v1beta/openai/"
+)
+
+client.chat(
+  parameters: {
+    model: "gemini-1.5-flash", # Required.
+    messages: [{ role: "user", content: "Hello!"}], # Required.
+    temperature: 0.7,
     stream: proc do |chunk, _bytesize|
      print chunk.dig("choices", 0, "delta", "content")
     end
   }
 )
+
+# => Hello there! How can I help you today?
 ```
 
 ### Counting Tokens
@@ -304,6 +390,12 @@ client.models.list
 client.models.retrieve(id: "gpt-4o")
 ```
 
+You can also delete any finetuned model you generated, if you're an account Owner on your OpenAI organization:
+
+```ruby
+client.models.delete(id: "ft:gpt-4o-mini:acemeco:suffix:abc123")
+```
+
 ### 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):
@@ -332,7 +424,7 @@ client.chat(
     model: "gpt-4o", # Required.
     messages: [{ role: "user", content: "Describe a character called Anna!"}], # Required.
     temperature: 0.7,
-    stream: proc do |chunk, _bytesize|
+    stream: proc do |chunk, _event|
       print chunk.dig("choices", 0, "delta", "content")
     end
   }
@@ -418,7 +510,7 @@ You can stream it as well!
       model: "gpt-4o",
       messages: [{ role: "user", content: "Can I have some JSON please?"}],
       response_format: { type: "json_object" },
-      stream: proc do |chunk, _bytesize|
+      stream: proc do |chunk, _event|
         print chunk.dig("choices", 0, "delta", "content")
       end
     }
@@ -441,6 +533,107 @@ You can stream it as well!
   # }
 ```
 
+### Responses API
+
+[OpenAI's most advanced interface for generating model responses](https://platform.openai.com/docs/api-reference/responses). Supports text and image inputs, and text outputs. Create stateful interactions with the model, using the output of previous responses as input. Extend the model's capabilities with built-in tools for file search, web search, computer use, and more. Allow the model access to external systems and data using function calling.
+
+#### Create a Response
+
+```ruby
+response = client.responses.create(parameters: {
+  model: "gpt-5",
+  input: "Hello! I'm Szymon!",
+  reasoning: {
+    "effort": "minimal"
+  }
+})
+puts response.dig("output", 0, "content", 0, "text")
+# => Thinking about how to answer this...
+puts response.dig("output", 1, "content", 0, "text")
+# => Hi Szymon! Great to meet you. How can I help today?
+```
+
+#### Follow-up Messages
+
+```ruby
+followup = client.responses.create(parameters: {
+  model: "gpt-4o",
+  input: "Remind me, what is my name?",
+  previous_response_id: response["id"]
+})
+puts followup.dig("output", 0, "content", 0, "text")
+# => Your name is Szymon! How can I help you today?
+```
+
+#### Tool Calls
+
+```ruby
+response = client.responses.create(parameters: {
+  model: "gpt-4o",
+  input: "What's the weather in Paris?",
+  tools: [
+    {
+      "type" => "function",
+      "name" => "get_current_weather",
+      "description" => "Get the current weather in a given location",
+      "parameters" => {
+        "type" => "object",
+        "properties" => {
+          "location" => {
+            "type" => "string",
+            "description" => "The geographic location to get the weather for"
+          }
+        },
+        "required" => ["location"]
+      }
+    }
+  ]
+})
+puts response.dig("output", 0, "name")
+# => "get_current_weather"
+```
+
+#### Streaming
+
+```ruby
+client.responses.create(
+  parameters: {
+    model: "gpt-4o", # Required.
+    input: "Hello!", # Required.
+    stream: proc do |chunk, _event|
+      if chunk["type"] == "response.output_text.delta"
+        print chunk["delta"]
+        $stdout.flush  # Ensure output is displayed immediately
+      end
+    end
+  }
+)
+# => "Hi there! How can I assist you today?..."
+```
+
+#### Retrieve a Response
+
+```ruby
+retrieved_response = client.responses.retrieve(response_id: response["id"])
+puts retrieved_response["object"]
+# => "response"
+```
+
+#### Delete a Response
+
+```ruby
+deletion = client.responses.delete(response_id: response["id"])
+puts deletion["deleted"]
+# => true
+```
+
+#### List Input Items
+
+```ruby
+input_items = client.responses.input_items(response_id: response["id"])
+puts input_items["object"] # => "list"
+```
+
 ### Functions
 
 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)).
@@ -495,6 +688,9 @@ response =
 message = response.dig("choices", 0, "message")
 
 if message["role"] == "assistant" && message["tool_calls"]
+  # For a subsequent message with the role "tool", OpenAI requires the preceding message to have a single tool_calls argument.
+  messages << message
+
   message["tool_calls"].each do |tool_call|
     tool_call_id = tool_call.dig("id")
     function_name = tool_call.dig("function", "name")
@@ -510,9 +706,6 @@ if message["role"] == "assistant" && message["tool_calls"]
         # decide how to handle
       end
 
-    # For a subsequent message with the role "tool", OpenAI requires the preceding message to have a tool_calls argument.
-    messages << message
-
     messages << {
       tool_call_id: tool_call_id,
       role: "tool",
@@ -746,6 +939,12 @@ You can also capture the events for a job:
 client.finetunes.list_events(id: fine_tune_id)
 ```
 
+You can also delete any finetuned model you generated, if you're an account Owner on your OpenAI organization:
+
+```ruby
+client.models.delete(id: fine_tune_id)
+```
+
 ### Vector Stores
 
 Vector Store objects give the File Search tool the ability to search your files.
@@ -786,6 +985,27 @@ response = client.vector_stores.modify(
 )
 ```
 
+You can search a vector store for relevant chunks based on a query:
+
+```ruby
+response = client.vector_stores.search(
+  id: vector_store_id,
+  parameters: {
+    query: "What is the return policy?",
+    max_num_results: 20,
+    ranking_options: {
+      # Add any ranking options here in line with the API documentation
+    },
+    rewrite_query: true,
+    filters: {
+      type: "eq",
+      property: "region",
+      value: "us"
+    }
+  }
+)
+```
+
 You can delete vector stores:
 
 ```ruby
@@ -879,6 +1099,128 @@ client.vector_store_file_batches.cancel(
 )
 ```
 
+### Conversations
+
+The Conversations API enables you to create and manage persistent conversations with your models. This is useful for maintaining conversation state across multiple interactions.
+
+**Supported Endpoints:**
+- `POST /v1/conversations` - Create a conversation
+- `GET /v1/conversations/{id}` - Retrieve a conversation  
+- `PATCH /v1/conversations/{id}` - Modify a conversation
+- `DELETE /v1/conversations/{id}` - Delete a conversation
+- `POST /v1/conversations/{id}/items` - Create items in a conversation
+- `GET /v1/conversations/{id}/items` - List items in a conversation
+- `GET /v1/conversations/{id}/items/{item_id}` - Get a specific item
+- `DELETE /v1/conversations/{id}/items/{item_id}` - Delete an item
+
+#### Creating a Conversation
+
+To create a new conversation:
+
+```ruby
+response = client.conversations.create(
+  parameters: {
+    metadata: { purpose: "customer_support" }
+  }
+)
+conversation_id = response["id"]
+```
+
+#### Retrieving a Conversation
+
+To retrieve a specific conversation:
+
+```ruby
+conversation = client.conversations.retrieve(id: conversation_id)
+```
+
+#### Modifying a Conversation
+
+To update a conversation's metadata:
+
+```ruby
+response = client.conversations.modify(
+  id: conversation_id,
+  parameters: {
+    metadata: { status: "resolved" }
+  }
+)
+```
+
+#### Deleting a Conversation
+
+To delete a conversation:
+
+```ruby
+response = client.conversations.delete(id: conversation_id)
+```
+
+#### Managing Items in Conversations
+
+You can add, retrieve, and manage items within a conversation.
+
+##### Creating Items
+
+```ruby
+# Create multiple items at once
+response = client.conversations.create_items(
+  conversation_id: conversation_id,
+  parameters: {
+    items: [
+      {
+        type: "message",
+        role: "user",
+        content: [
+          { type: "input_text", text: "Hello!" }
+        ]
+      },
+      {
+        type: "message",
+        role: "assistant",
+        content: [
+          { type: "input_text", text: "How are you?" }
+        ]
+      }
+    ]
+  }
+)
+```
+
+##### Listing Items
+
+```ruby
+# List all items in a conversation
+response = client.conversations.list_items(conversation_id: conversation_id)
+items = response["data"]
+
+# With parameters
+response = client.conversations.list_items(
+  conversation_id: conversation_id,
+  parameters: { 
+    limit: 10,
+    order: "asc"
+  }
+)
+```
+
+##### Retrieving a Specific Item
+
+```ruby
+item = client.conversations.get_item(
+  conversation_id: conversation_id,
+  item_id: item_id
+)
+```
+
+##### Deleting an Item
+
+```ruby
+response = client.conversations.delete_item(
+  conversation_id: conversation_id,
+  item_id: item_id
+)
+```
+
 ### Assistants
 
 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)).
@@ -1001,7 +1343,7 @@ client.runs.create(
     assistant_id: assistant_id,
     max_prompt_tokens: 256,
     max_completion_tokens: 16,
-    stream: proc do |chunk, _bytesize|
+    stream: proc do |chunk, _event|
       if chunk["object"] == "thread.message.delta"
         print chunk.dig("delta", "content", 0, "text", "value")
       end
@@ -1385,6 +1727,21 @@ puts response.dig("data", 0, "url")
 
 ![Ruby](https://i.ibb.co/sWVh3BX/dalle-ruby.png)
 
+You can also upload arrays of images, eg.
+
+```ruby
+  client = OpenAI::Client.new
+  response = client.images.edit(
+    parameters: {
+      model: "gpt-image-1",
+      image: [File.open(base_image_path, "rb"), "image.png"],
+      prompt: "Take the first image as base and apply the second image as a watermark on the bottom right corner",
+      size: "1024x1024"
+      # Removed response_format parameter as it's not supported with gpt-image-1
+    }
+  )
+```
+
 ### Image Variations
 
 Create n variations of an image.
@@ -1445,6 +1802,20 @@ puts response["text"]
 # => "Transcription of the text"
 ```
 
+If you are using Ruby on Rails with Active Storage, you would need to send an audio or video file like this (User has_one_attached):
+```ruby
+user.media.blob.open do |file|
+  response = client.audio.transcribe(
+    parameters: {
+        model: "whisper-1",
+        file: File.open(file, "rb"),
+        language: "en" # Optional
+    })
+  puts response["text"]
+  # => "Transcription of the text"
+end
+```
+
 #### Speech
 
 The speech API takes as input the text and a voice and returns the content of an audio file you can listen to.
@@ -1463,7 +1834,35 @@ File.binwrite('demo.mp3', response)
 # => mp3 file that plays: "This is a speech test!"
 ```
 
+### Realtime
+
+The [Realtime API](https://platform.openai.com/docs/guides/realtime) allows you to create a live speech-to-speech session with an OpenAI model. It responds with a session object, plus a client_secret key which contains a usable ephemeral API token that can be used to [authenticate browser clients for a WebRTC connection](https://platform.openai.com/docs/guides/realtime#connect-with-webrtc).
+
+```ruby
+response = client.realtime.create(parameters: { model: "gpt-4o-realtime-preview-2024-12-17" })
+puts "ephemeral key: #{response.dig('client_secret', 'value')}"
+# => "ephemeral key: ek_abc123"
+```
+
+Then in the client-side Javascript application, make a POST request to the Real-Time API with the ephemeral key and the SDP offer.
+
+```js
+const OPENAI_REALTIME_URL = 'https://api.openai.com/v1/realtime/sessions'
+const MODEL = 'gpt-4o-realtime-preview-2024-12-17'
+
+const response = await fetch(`${OPENAI_REALTIME_URL}?model=${MODEL}`, {
+  method: 'POST',
+  headers: {
+    'Content-Type': 'application/sdp',
+    'Authorization': `Bearer ${ephemeralKey}`,
+    'OpenAI-Beta': 'realtime=v1'
+  },
+  body: offer.sdp
+})
+```
+
 ### Usage
+
 The Usage API provides information about the cost of various OpenAI services within your organization.
 To use Admin APIs like Usage, you need to set an OPENAI_ADMIN_TOKEN, which can be generated [here](https://platform.openai.com/settings/organization/admin-keys).
 
@@ -1544,6 +1943,12 @@ To run all tests, execute the command `bundle exec rake`, which will also run th
 > [!WARNING]
 > If you have an `OPENAI_ACCESS_TOKEN` and `OPENAI_ADMIN_TOKEN` in your `ENV`, running the specs will hit the actual API, which will be slow and cost you money - 2 cents or more! Remove them from your environment with `unset` or similar if you just want to run the specs against the stored VCR responses.
 
+### To check for deprecations
+
+```
+bundle exec ruby -e "Warning[:deprecated] = true; require 'rspec'; exit RSpec::Core::Runner.run(['spec/openai/client/http_spec.rb:25'])"
+```
+
 ## Release
 
 First run the specs without VCR so they actually hit the API. This will cost 2 cents or more. Set OPENAI_ACCESS_TOKEN and OPENAI_ADMIN_TOKEN in your environment.

data/SECURITY.md

@@ -0,0 +1,9 @@
+# Security Policy
+
+Thank you for helping us keep ruby-openai and any systems it interacts with secure.
+
+## Reporting Security Issues
+
+The security of our systems and user data is our top priority. We appreciate the work of security researchers acting in good faith in identifying and reporting potential vulnerabilities.
+
+Any validated vulnerability in this functionality can be reported through Github - click on the [Security Tab](https://github.com/alexrudall/ruby-openai/security) and click "Report a vulnerability".

data/lib/openai/batches.rb

@@ -1,7 +1,7 @@
 module OpenAI
   class Batches
     def initialize(client:)
-      @client = client.beta(assistants: OpenAI::Assistants::BETA_VERSION)
+      @client = client
     end
 
     def list(parameters: {})

data/lib/openai/client.rb

@@ -1,3 +1,4 @@
+# rubocop:disable Metrics/ClassLength
 module OpenAI
   class Client
     include OpenAI::HTTP
@@ -5,7 +6,7 @@ module OpenAI
     SENSITIVE_ATTRIBUTES = %i[@access_token @admin_token @organization_id @extra_headers].freeze
     CONFIG_KEYS = %i[access_token admin_token api_type api_version extra_headers
                      log_errors organization_id request_timeout uri_base].freeze
-    attr_reader *CONFIG_KEYS, :faraday_middleware
+    attr_reader(*CONFIG_KEYS, :faraday_middleware)
     attr_writer :access_token
 
     def initialize(config = {}, &faraday_middleware)
@@ -52,6 +53,10 @@ module OpenAI
       @models ||= OpenAI::Models.new(client: self)
     end
 
+    def responses
+      @responses ||= OpenAI::Responses.new(client: self)
+    end
+
     def assistants
       @assistants ||= OpenAI::Assistants.new(client: self)
     end
@@ -88,6 +93,10 @@ module OpenAI
       @batches ||= OpenAI::Batches.new(client: self)
     end
 
+    def realtime
+      @realtime ||= OpenAI::Realtime.new(client: self)
+    end
+
     def moderations(parameters: {})
       json_post(path: "/moderations", parameters: parameters)
     end
@@ -96,6 +105,10 @@ module OpenAI
       @usage ||= OpenAI::Usage.new(client: self)
     end
 
+    def conversations
+      @conversations ||= OpenAI::Conversations.new(client: self)
+    end
+
     def azure?
       @api_type&.to_sym == :azure
     end
@@ -128,3 +141,4 @@ module OpenAI
     end
   end
 end
+# rubocop:enable Metrics/ClassLength