openai 0.78.0 → 0.80.0

data/bedrock.md

@@ -0,0 +1,197 @@
+# 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.
+
+## Bedrock Runtime
+
+Pass `endpoint: :runtime` to use the Bedrock Runtime OpenAI-compatible endpoint. The provider routes requests to `https://bedrock-runtime.<region>.amazonaws.com/openai/v1` and uses the AWS SigV4 signing service `bedrock` when AWS credentials are selected:
+
+```ruby
+require "openai"
+
+client = OpenAI::Client.new(
+  provider: OpenAI::Providers.bedrock(
+    endpoint: :runtime,
+    region: "us-east-1"
+  )
+)
+
+completion = client.chat.completions.create(
+  model: "us.openai.gpt-5.6-sol",
+  messages: [{role: :user, content: "Say hello!"}]
+)
+
+puts(completion.choices.first.message.content)
+```
+
+Use the inference profile configured for your AWS account, for example `us.openai.gpt-5.6-sol`, `us.openai.gpt-5.6-terra`, or `us.openai.gpt-5.6-luna`. Global inference profiles, such as `global.openai.gpt-5.6-sol`, require the appropriate AWS account and regional permissions. Set `BEDROCK_MODEL` to override the model used by [`examples/bedrock_runtime.rb`](examples/bedrock_runtime.rb). The example uses Chat Completions by default; set `BEDROCK_RESPONSES=1` to also use Responses or `BEDROCK_STREAM=1` to also stream Chat Completions. Set `BEDROCK_AUTH_MODE=sigv4` to explicitly select AWS authentication when a bearer credential is also present.
+
+The same client supports Responses and response streaming when AWS makes those APIs available for the selected model:
+
+```ruby
+response = client.responses.create(
+  model: "us.openai.gpt-5.6-sol",
+  input: "Say hello!"
+)
+
+stream = client.chat.completions.stream(
+  model: "us.openai.gpt-5.6-sol",
+  messages: [{role: :user, content: "Say hello!"}]
+)
+
+stream.text.each { |text| print(text) }
+```
+
+The existing Mantle endpoint remains the default. Pass `endpoint: :mantle` when you need to explicitly select it. Both endpoint symbols and the strings `"runtime"` and `"mantle"` are accepted.
+
+| Endpoint | Default URL | SigV4 signing service |
+| --- | --- | --- |
+| `:mantle` (default) | `https://bedrock-mantle.<region>.api.aws/v1` | `bedrock-mantle` |
+| `:runtime` | `https://bedrock-runtime.<region>.amazonaws.com/openai/v1` | `bedrock` |
+
+Runtime URLs automatically use the correct DNS suffix for AWS China, European Sovereign Cloud, and isolated partitions. Canonical Runtime, FIPS, and dual-stack `base_url` values automatically select Runtime when `endpoint` is omitted. Canonical AWS endpoint URLs must use HTTPS, match the selected endpoint family, and agree with the configured AWS region.
+
+## Endpoint configuration
+
+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(
+  endpoint: :runtime,
+  region: "us-west-2",
+  base_url: "https://bedrock.example.com/openai/v1"
+)
+```
+
+Custom endpoints using AWS credentials default to Mantle signing when `endpoint` is omitted; pass `endpoint: :runtime` to use Runtime signing. Local HTTP proxies remain supported when the endpoint is selected explicitly. Custom endpoints using bearer credentials can omit `endpoint`; in that case the default remains Mantle.
+
+## 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` for Mantle or `bedrock` for Runtime. 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.
+
+## Live verification
+
+Real AWS requests are disabled in the test suite unless `BEDROCK_LIVE_TEST=1` is explicitly set. To exercise Runtime against all three default US inference profiles, run:
+
+```sh
+AWS_REGION=us-east-1 BEDROCK_LIVE_TEST=1 \
+  bundle exec ruby test/openai/providers/bedrock_live_test.rb
+```
+
+Set `BEDROCK_AUTH_MODE` to `auto`, `bearer`, `token-provider`, `sigv4`, `static`, or `profile` to select credentials. Use `BEDROCK_MODEL` for one inference profile or `BEDROCK_LIVE_MODELS` for a comma-separated list. Set `BEDROCK_LIVE_RESPONSES=1` to also verify Responses and `BEDROCK_LIVE_STREAM=1` to verify Chat Completions streaming.
+
+## 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

@@ -229,9 +229,12 @@ 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]
     #
@@ -239,6 +242,13 @@ module OpenAI
     #
     # @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,
@@ -248,11 +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,
-      http_client: nil
+      http_client: nil,
+      logger: nil,
+      log_level: nil,
+      on_retry: nil
     )
       provider_runtime = nil
       unless provider.nil?
@@ -301,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
@@ -341,7 +361,10 @@ module OpenAI
         initial_retry_delay: initial_retry_delay,
         max_retry_delay: max_retry_delay,
         headers: headers,
-        http_client: http_client
+        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