openai 0.77.1 → 0.79.0

data/azure.md

@@ -0,0 +1,110 @@
+# Microsoft Azure OpenAI
+
+Configure the standard `OpenAI::Client` with the Azure provider to use the
+[Azure OpenAI v1 API](https://learn.microsoft.com/azure/foundry/openai/api-version-lifecycle):
+
+```ruby
+require "openai"
+
+client = OpenAI::Client.new(
+  provider: OpenAI::Providers.azure(
+    endpoint: ENV.fetch("AZURE_OPENAI_ENDPOINT"),
+    api_key: ENV.fetch("AZURE_OPENAI_API_KEY")
+  )
+)
+
+response = client.responses.create(
+  model: ENV.fetch("AZURE_OPENAI_DEPLOYMENT"),
+  input: "Say hello!"
+)
+
+puts(response.output_text)
+```
+
+The `model` parameter is the Azure model deployment name. The provider exposes
+the normal Ruby SDK resources, request and response models, retries, pagination,
+streaming helpers, and custom HTTP transport. Azure controls which resources and
+features are available for a deployment; unsupported calls surface as normal API
+errors.
+
+## Endpoint configuration
+
+Pass the Azure resource endpoint or set `AZURE_OPENAI_ENDPOINT`:
+
+```ruby
+provider = OpenAI::Providers.azure(
+  endpoint: "https://my-resource.openai.azure.com",
+  api_key: ENV.fetch("AZURE_OPENAI_API_KEY")
+)
+```
+
+The provider appends `/openai/v1` when it is absent. These values therefore
+configure the same base URL:
+
+```text
+https://my-resource.openai.azure.com
+https://my-resource.openai.azure.com/openai
+https://my-resource.openai.azure.com/openai/v1/
+```
+
+The endpoint must be an absolute HTTP or HTTPS URL without user information, a
+query string, or a fragment. Use HTTPS outside local testing. A path prefix is
+preserved for gateways and private routing, for example
+`https://gateway.example.com/azure` becomes
+`https://gateway.example.com/azure/openai/v1`.
+
+## Authentication
+
+Configure exactly one authentication mode explicitly. If neither is explicit,
+the provider uses `AZURE_OPENAI_API_KEY`.
+
+### Azure API key
+
+Pass `api_key` or set `AZURE_OPENAI_API_KEY`. The provider sends it in Azure's
+`api-key` header:
+
+```ruby
+provider = OpenAI::Providers.azure(
+  endpoint: ENV.fetch("AZURE_OPENAI_ENDPOINT"),
+  api_key: ENV.fetch("AZURE_OPENAI_API_KEY")
+)
+```
+
+Passing `api_key: nil` explicitly skips the environment fallback.
+
+### Microsoft Entra bearer token
+
+Pass a callable that returns a current access token for Azure OpenAI. Credential
+acquisition stays with the application, so the SDK does not require an Azure
+identity package:
+
+```ruby
+provider = OpenAI::Providers.azure(
+  endpoint: ENV.fetch("AZURE_OPENAI_ENDPOINT"),
+  token_provider: -> {
+    credential.get_token("https://cognitiveservices.azure.com/.default").token
+  }
+)
+```
+
+An explicit `token_provider` takes precedence over an ambient
+`AZURE_OPENAI_API_KEY`. It is invoked immediately before every request attempt,
+including API retries, so applications can refresh short-lived tokens without
+rebuilding the client.
+
+## Security
+
+The provider validates the request origin before attaching an API key or bearer
+token. It refuses to authenticate redirects or custom requests whose origin
+differs from the configured Azure endpoint. Custom `Authorization` and `api-key`
+headers cannot be combined with provider-owned authentication.
+
+Keep credentials out of source control and logs. Prefer short-lived Microsoft
+Entra tokens to long-lived API keys for production workloads.
+
+## Dated Azure APIs
+
+This provider targets the GA Azure OpenAI v1 API. It does not support dated API
+versions such as `2025-04-01-preview`, inject `api-version` query parameters, or
+rewrite generated resource paths to `/deployments/{deployment}`. Use the v1 API
+for new integrations.

data/bedrock.md

@@ -0,0 +1,132 @@
+# Amazon Bedrock
+
+Configure the standard `OpenAI::Client` with the Bedrock provider to use [Amazon Bedrock's OpenAI-compatible API](https://docs.aws.amazon.com/bedrock/latest/userguide/models-api-compatibility.html):
+
+```ruby
+require "openai"
+
+client = OpenAI::Client.new(
+  provider: OpenAI::Providers.bedrock(region: "us-west-2")
+)
+
+response = client.responses.create(
+  model: ENV.fetch("BEDROCK_MODEL"),
+  input: "Say hello!"
+)
+
+puts(response.output_text)
+```
+
+The provider uses `https://bedrock-mantle.<region>.api.aws/v1` by default and exposes the normal SDK resources. AWS controls which endpoints and features are supported; unsupported calls surface as normal API errors.
+
+The region is resolved from the explicit `region` option, `AWS_REGION`, `AWS_DEFAULT_REGION`, or the selected AWS profile. Override the endpoint with `base_url` or `AWS_BEDROCK_BASE_URL`:
+
+```ruby
+provider = OpenAI::Providers.bedrock(
+  region: "us-west-2",
+  base_url: "https://bedrock.example.com/v1"
+)
+```
+
+## Authentication
+
+The provider selects authentication in this order:
+
+1. One explicit mode passed to `bedrock(...)`: `api_key`, `token_provider`, static AWS credentials, `profile`, or `credentials_provider`.
+2. The Bedrock bearer credential in `AWS_BEARER_TOKEN_BEDROCK`.
+3. The standard AWS credential chain.
+
+Explicit bearer and AWS credential modes are mutually exclusive. Configure only one explicit AWS mode at a time.
+
+### AWS credentials and SigV4
+
+AWS authentication is an optional integration so applications that do not use Bedrock do not install or load AWS packages. Add the AWS SDK core gem to your application:
+
+```ruby
+gem "aws-sdk-core", "~> 3"
+```
+
+Then run `bundle install`. If you are not using Bundler, run `gem install aws-sdk-core`.
+
+Omit explicit authentication to use environment credentials, the shared credentials and config files, SSO or assume-role profiles, web identity, ECS credentials, or EC2 instance credentials:
+
+```ruby
+client = OpenAI::Client.new(
+  provider: OpenAI::Providers.bedrock(region: "us-west-2")
+)
+```
+
+Select a named profile with:
+
+```ruby
+client = OpenAI::Client.new(
+  provider: OpenAI::Providers.bedrock(
+    region: "us-west-2",
+    profile: "engineering"
+  )
+)
+```
+
+You can omit `region` when that profile defines one in `~/.aws/config`.
+
+Pass temporary credentials directly, including the session token:
+
+```ruby
+client = OpenAI::Client.new(
+  provider: OpenAI::Providers.bedrock(
+    region: "us-west-2",
+    access_key_id: ENV.fetch("AWS_ACCESS_KEY_ID"),
+    secret_access_key: ENV.fetch("AWS_SECRET_ACCESS_KEY"),
+    session_token: ENV["AWS_SESSION_TOKEN"]
+  )
+)
+```
+
+For credentials managed by your application, pass an AWS credential provider or a callable that returns `Aws::Credentials`. It is consulted before every request attempt, including retries:
+
+```ruby
+credentials_provider = lambda do
+  Aws::Credentials.new(
+    ENV.fetch("AWS_ACCESS_KEY_ID"),
+    ENV.fetch("AWS_SECRET_ACCESS_KEY"),
+    ENV["AWS_SESSION_TOKEN"]
+  )
+end
+
+client = OpenAI::Client.new(
+  provider: OpenAI::Providers.bedrock(
+    region: "us-west-2",
+    credentials_provider: credentials_provider
+  )
+)
+```
+
+The provider signs each finalized attempt with AWS SigV4 service name `bedrock-mantle`. Standard JSON API requests have replayable bodies and work normally. SigV4 rejects one-shot request streams before sending, and signed requests do not automatically follow redirects because a new target requires a new signature. Response streaming is unaffected.
+
+### Bearer authentication
+
+Pass a Bedrock bearer credential directly, set `AWS_BEARER_TOKEN_BEDROCK`, or use a callable to resolve a fresh token before every attempt:
+
+```ruby
+client = OpenAI::Client.new(
+  provider: OpenAI::Providers.bedrock(
+    region: "us-west-2",
+    api_key: ENV.fetch("BEDROCK_API_KEY")
+  )
+)
+```
+
+```ruby
+client = OpenAI::Client.new(
+  provider: OpenAI::Providers.bedrock(
+    region: "us-west-2",
+    token_provider: -> { refresh_bedrock_token }
+  )
+)
+```
+
+Bearer authentication does not load or require `aws-sdk-core`. Passing `api_key: nil` explicitly skips `AWS_BEARER_TOKEN_BEDROCK` and selects AWS authentication.
+
+## Security
+
+Use Bedrock from a server-side Ruby runtime. Prefer roles, profiles, SSO, and temporary credentials over long-lived static keys. Do not send AWS access keys, session tokens, bearer credentials, or signed authorization headers to browsers or application logs.

data/examples/mtls_custom_http_client.rb

@@ -0,0 +1,61 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# This example sends an API-key request over mutual TLS by configuring the
+# SDK's pooled Net::HTTP connections with Ruby's native OpenSSL support. Set
+# OPENAI_CLIENT_CERTIFICATE_CHAIN to a PEM file containing the leaf certificate
+# followed by any required intermediates, OPENAI_CLIENT_KEY to the matching
+# private key, and OPENAI_MODEL to a model available to the project.
+# OPENAI_CLIENT_KEY_PASSPHRASE is optional.
+
+require_relative "../lib/openai"
+
+# Set this to the mTLS endpoint for your data residency. EU Data Residency uses
+# https://mtls-eu.api.openai.com/v1. For enrollment and current endpoint
+# guidance, see:
+# https://help.openai.com/en/articles/10876024-openai-mutual-tls-beta-program
+mtls_endpoint = URI("https://mtls.api.openai.com/v1")
+certificates = OpenSSL::X509::Certificate.load(
+  File.binread(ENV.fetch("OPENAI_CLIENT_CERTIFICATE_CHAIN"))
+)
+raise ArgumentError, "Expected a client certificate" if certificates.empty?
+
+leaf_certificate, *intermediates = certificates
+private_key = OpenSSL::PKey.read(
+  File.binread(ENV.fetch("OPENAI_CLIENT_KEY")),
+  ENV["OPENAI_CLIENT_KEY_PASSPHRASE"]
+)
+unless leaf_certificate.check_private_key(private_key)
+  raise ArgumentError, "The client certificate and private key do not match"
+end
+
+now = Time.now
+raise ArgumentError, "The client certificate is not yet valid" if now < leaf_certificate.not_before
+raise ArgumentError, "The client certificate has expired" if now > leaf_certificate.not_after
+
+mtls_destination = [mtls_endpoint.host, mtls_endpoint.port]
+http_client = OpenAI::NetHTTPClient.new do |http|
+  unless http.use_ssl? && mtls_destination == [http.address, http.port]
+    raise ArgumentError, "Refusing to present the client certificate to an unexpected origin"
+  end
+
+  http.cert = leaf_certificate
+  http.extra_chain_cert = intermediates
+  http.key = private_key
+end
+
+client = OpenAI::Client.new(
+  api_key: ENV.fetch("OPENAI_API_KEY"),
+  base_url: mtls_endpoint.to_s,
+  http_client: http_client
+)
+
+begin
+  response = client.responses.create(
+    model: ENV.fetch("OPENAI_MODEL"),
+    input: "Reply with: mTLS transport configured"
+  )
+  puts(response.output_text)
+ensure
+  http_client.close
+end

data/lib/openai/auth/workload_identity.rb

@@ -6,12 +6,23 @@ module OpenAI
       attr_reader :client_id, :identity_provider_id, :service_account_id, :provider, :refresh_buffer_seconds
 
       def initialize(
-        identity_provider_id:,
-        service_account_id:,
         provider:,
+        identity_provider_id: ENV["IDENTITY_PROVIDER_ID"],
+        service_account_id: ENV["SERVICE_ACCOUNT_ID"],
         client_id: nil,
         refresh_buffer_seconds: 1200
       )
+        if identity_provider_id.to_s.strip.empty?
+          raise ArgumentError,
+                "identity_provider_id must not be blank; pass identity_provider_id: " \
+                "or set IDENTITY_PROVIDER_ID"
+        end
+
+        if service_account_id.to_s.strip.empty?
+          raise ArgumentError,
+                "service_account_id must not be blank; pass service_account_id: or set SERVICE_ACCOUNT_ID"
+        end
+
         @client_id = client_id&.to_s
         @identity_provider_id = identity_provider_id.to_s
         @service_account_id = service_account_id.to_s

data/lib/openai/auth/workload_identity_auth.rb

@@ -87,7 +87,8 @@ module OpenAI
         token_type = @config.provider.token_type
         subject_token_type = SUBJECT_TOKEN_TYPES.fetch(token_type) do
           raise ArgumentError,
-                "Unsupported token type: #{token_type.inspect}. Supported types: #{SUBJECT_TOKEN_TYPES.keys.join(', ')}"
+                "Unsupported token type: #{token_type.inspect}. " \
+                "Supported types: #{SUBJECT_TOKEN_TYPES.keys.join(', ')}"
         end
 
         request = Net::HTTP::Post.new(@token_exchange_url)

data/lib/openai/client.rb

@@ -163,14 +163,6 @@ module OpenAI
     #   Mutually exclusive with `workload_identity`.
     #
 
-    # @api private
-    private def request_replayable?(request)
-      body = request[:body]
-      return true if body.nil? || body.is_a?(String)
-      return false if body.respond_to?(:read)
-      true
-    end
-
     # @api private
     private def prepare_request(request, redirect_count:, retry_count:)
       preparer = @provider_runtime&.prepare_request
@@ -237,13 +229,26 @@ module OpenAI
     # @param base_url [String, nil] Override the default base URL for the API, e.g.,
     # `"https://api.example.com/v2/"`. Defaults to `ENV["OPENAI_BASE_URL"]`
     #
+    # @param default_headers [Hash{String=>String, nil}, nil] Extra headers to send
+    #   with every request. Explicit values override `ENV["OPENAI_CUSTOM_HEADERS"]`.
+    #
     # @param max_retries [Integer] Max number of retries to attempt after a failed retryable request.
     #
-    # @param timeout [Float]
+    # @param timeout [Float, nil]
     #
     # @param initial_retry_delay [Float]
     #
     # @param max_retry_delay [Float]
+    #
+    # @param http_client [#execute, nil] The HTTP client used to
+    #   execute SDK requests. Defaults to {OpenAI::NetHTTPClient}.
+    #
+    # @param logger [#debug, #info, #warn, #error, nil] Logger for SDK request diagnostics.
+    #
+    # @param log_level [Symbol, String, nil] SDK request log level. Defaults to
+    #   `ENV["OPENAI_LOG"]`, `:info` when `logger` is provided, and `:off` otherwise.
+    #
+    # @param on_retry [Proc, nil] Callback invoked immediately before an API retry delay.
     def initialize(
       api_key: OpenAI::Internal::OMIT,
       admin_api_key: OpenAI::Internal::OMIT,
@@ -253,10 +258,15 @@ module OpenAI
       webhook_secret: OpenAI::Internal::OMIT,
       provider: nil,
       base_url: OpenAI::Internal::OMIT,
+      default_headers: nil,
       max_retries: self.class::DEFAULT_MAX_RETRIES,
       timeout: self.class::DEFAULT_TIMEOUT_IN_SECONDS,
       initial_retry_delay: self.class::DEFAULT_INITIAL_RETRY_DELAY,
-      max_retry_delay: self.class::DEFAULT_MAX_RETRY_DELAY
+      max_retry_delay: self.class::DEFAULT_MAX_RETRY_DELAY,
+      http_client: nil,
+      logger: nil,
+      log_level: nil,
+      on_retry: nil
     )
       provider_runtime = nil
       unless provider.nil?
@@ -305,24 +315,30 @@ module OpenAI
 
       if provider_runtime.nil? && api_key.nil? && admin_api_key.nil? && workload_identity.nil?
         raise ArgumentError,
-              "Missing credentials. Please pass an `api_key`, `workload_identity`, `admin_api_key`, or set the `OPENAI_API_KEY` or `OPENAI_ADMIN_KEY` environment variable."
+              "Missing credentials. Please pass an `api_key`, `workload_identity`, " \
+              "`admin_api_key`, or set the `OPENAI_API_KEY` or `OPENAI_ADMIN_KEY` " \
+              "environment variable."
       end
 
       headers = {
         "openai-organization" => (@organization = organization&.to_s),
         "openai-project" => (@project = project&.to_s)
       }
+      parsed = {}
       custom_headers_env = ENV["OPENAI_CUSTOM_HEADERS"] unless provider_runtime
       unless custom_headers_env.nil?
-        parsed = {}
         custom_headers_env.split("\n").each do |line|
           colon = line.index(":")
           unless colon.nil?
             parsed[line[0...colon].strip] = line[(colon + 1)..].strip
           end
         end
-        headers = parsed.merge(headers)
       end
+      client_headers = OpenAI::Internal::Util.normalized_headers(default_headers.to_h)
+      unless provider_runtime.nil?
+        provider_runtime.authentication_headers.each { client_headers.delete(_1) }
+      end
+      headers = OpenAI::Internal::Util.normalized_headers(parsed, headers, client_headers)
 
       if workload_identity.nil?
         @api_key = api_key&.to_s
@@ -344,7 +360,11 @@ module OpenAI
         max_retries: max_retries,
         initial_retry_delay: initial_retry_delay,
         max_retry_delay: max_retry_delay,
-        headers: headers
+        headers: headers,
+        http_client: http_client,
+        logger: logger,
+        log_level: log_level,
+        on_retry: on_retry
       )
 
       @completions = OpenAI::Resources::Completions.new(client: self)

data/lib/openai/errors.rb

@@ -58,6 +58,13 @@ module OpenAI
       # @return [String, nil]
       attr_accessor :type
 
+      # The ID of the API request, returned via the `x-request-id` response
+      # header. This is nil when no HTTP response was received or the response
+      # did not include the header.
+      #
+      # @return [String, nil]
+      def request_id = headers&.[]("x-request-id")
+
       # @api private
       #
       # @param url [URI::Generic]
@@ -269,7 +276,10 @@ module OpenAI
       attr_reader :error_code
 
       def initialize(status:, body:, headers:)
-        @error_code = OpenAI::Internal::Type::Converter.coerce(OpenAI::Models::OAuthErrorCode, body&.dig(:error))
+        @error_code = OpenAI::Internal::Type::Converter.coerce(
+          OpenAI::Models::OAuthErrorCode,
+          body&.dig(:error)
+        )
 
         message =
           if body&.dig(:error_description)

data/lib/openai/helpers/streaming/chat_completion_stream.rb

@@ -8,6 +8,7 @@ module OpenAI
 
         def initialize(raw_stream:, response_format: nil, input_tools: nil)
           @raw_stream = raw_stream
+          @last_response = raw_stream.last_response
           @state = ChatCompletionStreamState.new(
             response_format: response_format,
             input_tools: input_tools
@@ -33,7 +34,7 @@ module OpenAI
         end
 
         def until_done
-          each {} # rubocop:disable Lint/EmptyBlock
+          each { |_event| next }
           self
         end
 
@@ -507,8 +508,7 @@ module OpenAI
 
                 index = delta_entry[:index] || delta_entry["index"]
                 if index.nil?
-                  raise RuntimeError,
-                        "Expected list delta entry to have an `index` key; #{delta_entry}"
+                  raise "Expected list delta entry to have an `index` key; #{delta_entry}"
                 end
                 unless index.is_a?(Integer)
                   raise TypeError,

data/lib/openai/helpers/streaming/response_stream.rb

@@ -10,6 +10,7 @@ module OpenAI
           @text_format = text_format
           @starting_after = starting_after
           @raw_stream = raw_stream
+          @last_response = raw_stream.last_response
           @iterator = iterator
           @state = ResponseStreamState.new(
             text_format: text_format
@@ -17,7 +18,7 @@ module OpenAI
         end
 
         def until_done
-          each {} # rubocop:disable Lint/EmptyBlock
+          each { |_event| next }
           self
         end
 
@@ -35,7 +36,7 @@ module OpenAI
         def get_final_response
           until_done
           response = @state.completed_response
-          raise RuntimeError.new("Didn't receive a 'response.completed' event") unless response
+          raise "Didn't receive a 'response.completed' event" unless response
           response
         end
 
@@ -218,10 +219,8 @@ module OpenAI
             parsed = JSON.parse(text, symbolize_names: true)
             OpenAI::Internal::Type::Converter.coerce(@text_format, parsed)
           rescue JSON::ParserError => e
-            raise RuntimeError.new(
-              "Failed to parse structured text as JSON for #{@text_format}: #{e.message}. " \
-              "Raw text: #{text.inspect}"
-            )
+            raise "Failed to parse structured text as JSON for #{@text_format}: #{e.message}. " \
+                  "Raw text: #{text.inspect}"
           end
         end
       end

data/lib/openai/helpers/structured_output/base_model.rb

@@ -25,26 +25,27 @@ module OpenAI
           #
           # @return [Hash{Symbol=>Object}]
           def to_json_schema_inner(state:)
+            field_values = fields.values
+            duplicate = field_values.map { _1.fetch(:api_name) }.tally.find { _2 > 1 }
+            raise ArgumentError.new("Duplicate API field name: #{duplicate.first}") if duplicate
+
             OpenAI::Helpers::StructuredOutput::JsonSchemaConverter.cache_def!(state, type: self) do
               path = state.fetch(:path)
-              properties = fields.to_h do |name, field|
-                type, nilable, meta = field.fetch_values(:type, :nilable, :meta)
-                new_state = {**state, path: [*path, ".#{name}"]}
+              properties = field_values.to_h do |field|
+                api_name, type, nilable, meta = field.fetch_values(:api_name, :type, :nilable, :meta)
+                new_state = {**state, path: [*path, ".#{api_name}"]}
 
-                schema =
-                  case type
-                  in OpenAI::Helpers::StructuredOutput::JsonSchemaConverter
-                    type.to_json_schema_inner(state: new_state)
-                  else
-                    OpenAI::Helpers::StructuredOutput::JsonSchemaConverter.to_json_schema_inner(
-                      type,
-                      state: new_state
-                    )
-                  end
+                schema = OpenAI::Helpers::StructuredOutput::JsonSchemaConverter.to_json_schema_inner(
+                  type,
+                  state: new_state
+                )
                 schema = OpenAI::Helpers::StructuredOutput::JsonSchemaConverter.to_nilable(schema) if nilable
-                OpenAI::Helpers::StructuredOutput::JsonSchemaConverter.assoc_meta!(schema, meta: meta)
+                OpenAI::Helpers::StructuredOutput::JsonSchemaConverter.assoc_meta!(
+                  schema,
+                  meta: meta.except(:api_name)
+                )
 
-                [name, schema]
+                [api_name, schema]
               end
 
               {
@@ -59,10 +60,10 @@ module OpenAI
 
         class << self
           def optional(...)
-            # rubocop:disable Layout/LineLength
-            message = "`optional` is not supported for structured output APIs, use `#required` with `nil?: true` instead"
-            # rubocop:enable Layout/LineLength
-            raise RuntimeError.new(message)
+            message =
+              "`optional` is not supported for structured output APIs, " \
+              "use `#required` with `nil?: true` instead"
+            raise message
           end
         end
       end

data/lib/openai/helpers/structured_output/json_schema_converter.rb

@@ -98,7 +98,10 @@ module OpenAI
               }
               defs.store(type, stored)
               schema = blk.call
-              ref_path.replace("#/$defs/#{path.join('/')}")
+              definition_name = path.map { _1.gsub("~", "~0").gsub("/", "~1") }.join("/")
+              pointer_token = definition_name.gsub("~", "~0").gsub("/", "~1")
+              escaped_name = URI::RFC2396_PARSER.escape(pointer_token, /[^A-Za-z0-9._~-]/)
+              ref_path.replace("#/$defs/#{escaped_name}")
               stored.update(schema)
               ref
             end
@@ -140,7 +143,10 @@ module OpenAI
               no_refs.each { _1.replace(_1.except(:$ref).merge(sch)) }
             end
 
-            xformed = reused_defs.transform_keys { _1.delete_prefix("#/$defs/") }
+            xformed = reused_defs.transform_keys do
+              pointer_token = URI::RFC2396_PARSER.unescape(_1.delete_prefix("#/$defs/"))
+              pointer_token.gsub("~1", "/").gsub("~0", "~")
+            end
             xformed.empty? ? schema : {"$defs": xformed}.update(schema)
           end
 
@@ -190,9 +196,10 @@ module OpenAI
               OpenAI::UnionOf
               OpenAI::BaseModel
             ]
-            # rubocop:disable Layout/LineLength
-            message = "#{type} does not implement the #{OpenAI::Helpers::StructuredOutput::JsonSchemaConverter} interface. Please use one of the supported types: #{models}"
-            # rubocop:enable Layout/LineLength
+            message =
+              "#{type} does not implement the " \
+              "#{OpenAI::Helpers::StructuredOutput::JsonSchemaConverter} interface. " \
+              "Please use one of the supported types: #{models}"
             raise ArgumentError.new(message)
           end
         end