openai 0.11.0 → 0.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 252a9ce9833b0a9f66be94b76081f34716e348ebca732e63c3e16c105ed42ea1
-  data.tar.gz: d4d8b36822ee74af77508ec8e48b472d72d619333e468055695158e242c49760
+  metadata.gz: c46771d67ac54a96ea533d6473403bd7357164093ad318367a59a9e4f8d526c4
+  data.tar.gz: c2c858697c822c515ebc105aeb69ecfabdfd515fdc2886ca308ffaa267c2c893
 SHA512:
-  metadata.gz: f27c40e40df727c8da570a4f6b1e20f72a87baa710efd3957bb0fbbcc23eb1dd78d03b1bcc3c3cf5684d4db4b062c392c1c3d970093c8e0fac89ef85db053db3
-  data.tar.gz: 21fe44d1605c6196d7321dcb7efa7d951a2523ba71859eab1bf242ff3314afe0cce25201c21b141f9f3902b684cb577ba51c520d12602d1279eccb770769e3a4
+  metadata.gz: efa25f9aab25791e58bd2a941953a37b54df6a01c98b0e4bbb0363f8739d7856e8e1b56804bc326315a7861ecfa5082a8b93eee7b429d9db09fe4c2b9b3455d5
+  data.tar.gz: 51b7aab418c9864b7375f457fdcd45380a437361ec72eabad9aca55050ff9ee6ca9f213d5cc037661ae56e75ed12a53160d7819dcbfc2f549b1c82f7b4ae6daa

data/CHANGELOG.md

@@ -1,5 +1,29 @@
 # Changelog
 
+## 0.13.0 (2025-07-10)
+
+Full Changelog: [v0.12.0...v0.13.0](https://github.com/openai/openai-ruby/compare/v0.12.0...v0.13.0)
+
+### Features
+
+* **api:** add file_url, fix event ID ([9b8919d](https://github.com/openai/openai-ruby/commit/9b8919d470b622035f13c455aa9aa783feb1f936))
+
+## 0.12.0 (2025-07-03)
+
+Full Changelog: [v0.11.0...v0.12.0](https://github.com/openai/openai-ruby/compare/v0.11.0...v0.12.0)
+
+### Features
+
+* ensure partial jsons in structured ouput are handled gracefully ([#740](https://github.com/openai/openai-ruby/issues/740)) ([5deec70](https://github.com/openai/openai-ruby/commit/5deec708bad1ceb1a03e9aa65f737e3f89ce6455))
+* responses streaming helpers ([#721](https://github.com/openai/openai-ruby/issues/721)) ([c2f4270](https://github.com/openai/openai-ruby/commit/c2f42708e41492f1c22886735079973510fb2789))
+
+
+### Chores
+
+* **ci:** only run for pushes and fork pull requests ([97538e2](https://github.com/openai/openai-ruby/commit/97538e266f6f9a0e09669453539ee52ca56f4f59))
+* **internal:** allow streams to also be unwrapped on a per-row basis ([49bdadf](https://github.com/openai/openai-ruby/commit/49bdadfc0d3400664de0c8e7cfd59879faec45b8))
+* **internal:** minor refactoring of json helpers ([#744](https://github.com/openai/openai-ruby/issues/744)) ([f13edee](https://github.com/openai/openai-ruby/commit/f13edee16325be04335443cb886a7c2024155fd9))
+
 ## 0.11.0 (2025-06-26)
 
 Full Changelog: [v0.10.0...v0.11.0](https://github.com/openai/openai-ruby/compare/v0.10.0...v0.11.0)

data/README.md

@@ -15,7 +15,7 @@ To use this gem, install via Bundler by adding the following to your application
 <!-- x-release-please-start-version -->
 
 ```ruby
-gem "openai", "~> 0.11.0"
+gem "openai", "~> 0.13.0"
 ```
 
 <!-- x-release-please-end -->
@@ -42,16 +42,14 @@ puts(chat_completion)
 
 We provide support for streaming responses using Server-Sent Events (SSE).
 
-**coming soon:** `openai.chat.completions.stream` will soon come with Python SDK-style higher-level streaming responses support.
-
 ```ruby
-stream = openai.chat.completions.stream_raw(
-  messages: [{role: "user", content: "Say this is a test"}],
+stream = openai.responses.stream(
+  input: "Write a haiku about OpenAI.",
   model: :"gpt-4.1"
 )
 
-stream.each do |completion|
-  puts(completion)
+stream.each do |event|
+  puts(event.type)
 end
 ```
 

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module OpenAI
+  module Helpers
+    module Streaming
+      class ResponseTextDeltaEvent < OpenAI::Models::Responses::ResponseTextDeltaEvent
+        required :snapshot, String
+      end
+
+      class ResponseTextDoneEvent < OpenAI::Models::Responses::ResponseTextDoneEvent
+        optional :parsed, Object
+      end
+
+      class ResponseFunctionCallArgumentsDeltaEvent < OpenAI::Models::Responses::ResponseFunctionCallArgumentsDeltaEvent
+        required :snapshot, String
+      end
+
+      class ResponseCompletedEvent < OpenAI::Models::Responses::ResponseCompletedEvent
+        required :response, OpenAI::Models::Responses::Response
+      end
+    end
+  end
+end

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

@@ -0,0 +1,232 @@
+# frozen_string_literal: true
+
+require_relative "events"
+
+module OpenAI
+  module Helpers
+    module Streaming
+      class ResponseStream
+        include OpenAI::Internal::Type::BaseStream
+
+        def initialize(raw_stream:, text_format: nil, starting_after: nil)
+          @text_format = text_format
+          @starting_after = starting_after
+          @raw_stream = raw_stream
+          @iterator = iterator
+          @state = ResponseStreamState.new(
+            text_format: text_format
+          )
+        end
+
+        def until_done
+          each {} # rubocop:disable Lint/EmptyBlock
+          self
+        end
+
+        def text
+          OpenAI::Internal::Util.chain_fused(@iterator) do |yielder|
+            @iterator.each do |event|
+              case event
+              when OpenAI::Streaming::ResponseTextDeltaEvent
+                yielder << event.delta
+              end
+            end
+          end
+        end
+
+        def get_final_response
+          until_done
+          response = @state.completed_response
+          raise RuntimeError.new("Didn't receive a 'response.completed' event") unless response
+          response
+        end
+
+        def get_output_text
+          response = get_final_response
+          text_parts = []
+
+          response.output.each do |output|
+            next unless output.type == :message
+
+            output.content.each do |content|
+              next unless content.type == :output_text
+              text_parts << content.text
+            end
+          end
+
+          text_parts.join
+        end
+
+        private
+
+        def iterator
+          @iterator ||= OpenAI::Internal::Util.chain_fused(@raw_stream) do |y|
+            @raw_stream.each do |raw_event|
+              events_to_yield = @state.handle_event(raw_event)
+              events_to_yield.each do |event|
+                if @starting_after.nil? || event.sequence_number > @starting_after
+                  y << event
+                end
+              end
+            end
+          end
+        end
+      end
+
+      class ResponseStreamState
+        attr_reader :completed_response
+
+        def initialize(text_format:)
+          @current_snapshot = nil
+          @completed_response = nil
+          @text_format = text_format
+        end
+
+        def handle_event(event)
+          @current_snapshot = accumulate_event(
+            event: event,
+            current_snapshot: @current_snapshot
+          )
+
+          events_to_yield = []
+
+          case event
+          when OpenAI::Models::Responses::ResponseTextDeltaEvent
+            output = @current_snapshot.output[event.output_index]
+            assert_type(output, :message)
+
+            content = output.content[event.content_index]
+            assert_type(content, :output_text)
+
+            events_to_yield << OpenAI::Streaming::ResponseTextDeltaEvent.new(
+              content_index: event.content_index,
+              delta: event.delta,
+              item_id: event.item_id,
+              output_index: event.output_index,
+              sequence_number: event.sequence_number,
+              type: event.type,
+              snapshot: content.text
+            )
+
+          when OpenAI::Models::Responses::ResponseTextDoneEvent
+            output = @current_snapshot.output[event.output_index]
+            assert_type(output, :message)
+
+            content = output.content[event.content_index]
+            assert_type(content, :output_text)
+
+            parsed = parse_structured_text(content.text)
+
+            events_to_yield << OpenAI::Streaming::ResponseTextDoneEvent.new(
+              content_index: event.content_index,
+              item_id: event.item_id,
+              output_index: event.output_index,
+              sequence_number: event.sequence_number,
+              text: event.text,
+              type: event.type,
+              parsed: parsed
+            )
+
+          when OpenAI::Models::Responses::ResponseFunctionCallArgumentsDeltaEvent
+            output = @current_snapshot.output[event.output_index]
+            assert_type(output, :function_call)
+
+            events_to_yield << OpenAI::Streaming::ResponseFunctionCallArgumentsDeltaEvent.new(
+              delta: event.delta,
+              item_id: event.item_id,
+              output_index: event.output_index,
+              sequence_number: event.sequence_number,
+              type: event.type,
+              snapshot: output.arguments
+            )
+
+          when OpenAI::Models::Responses::ResponseCompletedEvent
+            events_to_yield << OpenAI::Streaming::ResponseCompletedEvent.new(
+              sequence_number: event.sequence_number,
+              type: event.type,
+              response: event.response
+            )
+
+          else
+            # Pass through other events unchanged.
+            events_to_yield << event
+          end
+
+          events_to_yield
+        end
+
+        def accumulate_event(event:, current_snapshot:)
+          if current_snapshot.nil?
+            unless event.is_a?(OpenAI::Models::Responses::ResponseCreatedEvent)
+              raise "Expected first event to be response.created"
+            end
+
+            # Use the converter to create a new, isolated copy of the response object.
+            # This ensures proper type validation and prevents shared object references.
+            return OpenAI::Internal::Type::Converter.coerce(
+              OpenAI::Models::Responses::Response,
+              event.response
+            )
+          end
+
+          case event
+          when OpenAI::Models::Responses::ResponseOutputItemAddedEvent
+            current_snapshot.output.push(event.item)
+
+          when OpenAI::Models::Responses::ResponseContentPartAddedEvent
+            output = current_snapshot.output[event.output_index]
+            if output && output.type == :message
+              output.content.push(event.part)
+              current_snapshot.output[event.output_index] = output
+            end
+
+          when OpenAI::Models::Responses::ResponseTextDeltaEvent
+            output = current_snapshot.output[event.output_index]
+            if output && output.type == :message
+              content = output.content[event.content_index]
+              if content && content.type == :output_text
+                content.text += event.delta
+                output.content[event.content_index] = content
+                current_snapshot.output[event.output_index] = output
+              end
+            end
+
+          when OpenAI::Models::Responses::ResponseFunctionCallArgumentsDeltaEvent
+            output = current_snapshot.output[event.output_index]
+            if output && output.type == :function_call
+              output.arguments = (output.arguments || "") + event.delta
+              current_snapshot.output[event.output_index] = output
+            end
+
+          when OpenAI::Models::Responses::ResponseCompletedEvent
+            @completed_response = event.response
+          end
+
+          current_snapshot
+        end
+
+        private
+
+        def assert_type(object, expected_type)
+          return if object && object.type == expected_type
+          actual_type = object ? object.type : "nil"
+          raise "Invalid state: expected #{expected_type} but got #{actual_type}"
+        end
+
+        def parse_structured_text(text)
+          return nil unless @text_format && text
+
+          begin
+            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}"
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module OpenAI
+  module Helpers
+    module StructuredOutput
+      # @abstract
+      #
+      # Like OpenAI::Internal::Type::Unknown, but for parsed JSON values, which can be incomplete or malformed.
+      class ParsedJson < OpenAI::Internal::Type::Unknown
+        class << self
+          # @api private
+          #
+          # No coercion needed for Unknown type.
+          #
+          # @param value [Object]
+          #
+          # @param state [Hash{Symbol=>Object}] .
+          #
+          #   @option state [Boolean] :translate_names
+          #
+          #   @option state [Boolean] :strictness
+          #
+          #   @option state [Hash{Symbol=>Object}] :exactness
+          #
+          #   @option state [Class<StandardError>] :error
+          #
+          #   @option state [Integer] :branched
+          #
+          # @return [Object]
+          def coerce(value, state:)
+            (state[:error] = value) if value.is_a?(StandardError)
+
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/openai/internal/stream.rb

@@ -47,7 +47,8 @@ module OpenAI
                   message: message
                 )
               in decoded
-                y << OpenAI::Internal::Type::Converter.coerce(@model, decoded)
+                unwrapped = OpenAI::Internal::Util.dig(decoded, @unwrap)
+                y << OpenAI::Internal::Type::Converter.coerce(@model, unwrapped)
               end
             else
             end

data/lib/openai/internal/transport/base_client.rb

@@ -471,6 +471,7 @@ module OpenAI
           self.class.validate!(req)
           model = req.fetch(:model) { OpenAI::Internal::Type::Unknown }
           opts = req[:options].to_h
+          unwrap = req[:unwrap]
           OpenAI::RequestOptions.validate!(opts)
           request = build_request(req.except(:options), opts)
           url = request.fetch(:url)
@@ -487,11 +488,18 @@ module OpenAI
           decoded = OpenAI::Internal::Util.decode_content(response, stream: stream)
           case req
           in {stream: Class => st}
-            st.new(model: model, url: url, status: status, response: response, stream: decoded)
+            st.new(
+              model: model,
+              url: url,
+              status: status,
+              response: response,
+              unwrap: unwrap,
+              stream: decoded
+            )
           in {page: Class => page}
             page.new(client: self, req: req, headers: response, page_data: decoded)
           else
-            unwrapped = OpenAI::Internal::Util.dig(decoded, req[:unwrap])
+            unwrapped = OpenAI::Internal::Util.dig(decoded, unwrap)
             OpenAI::Internal::Type::Converter.coerce(model, unwrapped)
           end
         end

data/lib/openai/internal/type/base_stream.rb

@@ -64,12 +64,14 @@ module OpenAI
         # @param url [URI::Generic]
         # @param status [Integer]
         # @param response [Net::HTTPResponse]
+        # @param unwrap [Symbol, Integer, Array<Symbol, Integer>, Proc]
         # @param stream [Enumerable<Object>]
-        def initialize(model:, url:, status:, response:, stream:)
+        def initialize(model:, url:, status:, response:, unwrap:, stream:)
           @model = model
           @url = url
           @status = status
           @response = response
+          @unwrap = unwrap
           @stream = stream
           @iterator = iterator
 

data/lib/openai/models/audio/transcription.rb

@@ -149,11 +149,11 @@ module OpenAI
           end
 
           class Duration < OpenAI::Internal::Type::BaseModel
-            # @!attribute duration
+            # @!attribute seconds
             #   Duration of the input audio in seconds.
             #
             #   @return [Float]
-            required :duration, Float
+            required :seconds, Float
 
             # @!attribute type
             #   The type of the usage object. Always `duration` for this variant.
@@ -161,10 +161,10 @@ module OpenAI
             #   @return [Symbol, :duration]
             required :type, const: :duration
 
-            # @!method initialize(duration:, type: :duration)
+            # @!method initialize(seconds:, type: :duration)
             #   Usage statistics for models billed by audio input duration.
             #
-            #   @param duration [Float] Duration of the input audio in seconds.
+            #   @param seconds [Float] Duration of the input audio in seconds.
             #
             #   @param type [Symbol, :duration] The type of the usage object. Always `duration` for this variant.
           end

data/lib/openai/models/audio/transcription_verbose.rb

@@ -58,11 +58,11 @@ module OpenAI
 
         # @see OpenAI::Models::Audio::TranscriptionVerbose#usage
         class Usage < OpenAI::Internal::Type::BaseModel
-          # @!attribute duration
+          # @!attribute seconds
           #   Duration of the input audio in seconds.
           #
           #   @return [Float]
-          required :duration, Float
+          required :seconds, Float
 
           # @!attribute type
           #   The type of the usage object. Always `duration` for this variant.
@@ -70,10 +70,10 @@ module OpenAI
           #   @return [Symbol, :duration]
           required :type, const: :duration
 
-          # @!method initialize(duration:, type: :duration)
+          # @!method initialize(seconds:, type: :duration)
           #   Usage statistics for models billed by audio input duration.
           #
-          #   @param duration [Float] Duration of the input audio in seconds.
+          #   @param seconds [Float] Duration of the input audio in seconds.
           #
           #   @param type [Symbol, :duration] The type of the usage object. Always `duration` for this variant.
         end

data/lib/openai/models/chat/chat_completion_message.rb

@@ -14,7 +14,7 @@ module OpenAI
         #   The parsed contents of the message, if JSON schema is specified.
         #
         #   @return [Object, nil]
-        optional :parsed, OpenAI::Internal::Type::Unknown
+        optional :parsed, OpenAI::StructuredOutput::ParsedJson
 
         # @!attribute refusal
         #   The refusal message generated by the model.

data/lib/openai/models/chat/chat_completion_message_tool_call.rb

@@ -44,7 +44,7 @@ module OpenAI
           #   The parsed contents of the arguments.
           #
           #   @return [Object, nil]
-          required :parsed, OpenAI::Internal::Type::Unknown
+          required :parsed, OpenAI::StructuredOutput::ParsedJson
 
           # @!attribute name
           #   The name of the function to call.

data/lib/openai/models/file_object.rb

@@ -36,8 +36,8 @@ module OpenAI
 
       # @!attribute purpose
       #   The intended purpose of the file. Supported values are `assistants`,
-      #   `assistants_output`, `batch`, `batch_output`, `fine-tune`, `fine-tune-results`
-      #   and `vision`.
+      #   `assistants_output`, `batch`, `batch_output`, `fine-tune`, `fine-tune-results`,
+      #   `vision`, and `user_data`.
       #
       #   @return [Symbol, OpenAI::Models::FileObject::Purpose]
       required :purpose, enum: -> { OpenAI::FileObject::Purpose }
@@ -91,8 +91,8 @@ module OpenAI
       #   @param object [Symbol, :file] The object type, which is always `file`.
 
       # The intended purpose of the file. Supported values are `assistants`,
-      # `assistants_output`, `batch`, `batch_output`, `fine-tune`, `fine-tune-results`
-      # and `vision`.
+      # `assistants_output`, `batch`, `batch_output`, `fine-tune`, `fine-tune-results`,
+      # `vision`, and `user_data`.
       #
       # @see OpenAI::Models::FileObject#purpose
       module Purpose
@@ -105,6 +105,7 @@ module OpenAI
         FINE_TUNE = :"fine-tune"
         FINE_TUNE_RESULTS = :"fine-tune-results"
         VISION = :vision
+        USER_DATA = :user_data
 
         # @!method self.values
         #   @return [Array<Symbol>]

data/lib/openai/models/responses/response_function_tool_call.rb

@@ -14,7 +14,7 @@ module OpenAI
         #   The parsed contents of the arguments.
         #
         #   @return [Object, nil]
-        required :parsed, OpenAI::Internal::Type::Unknown
+        required :parsed, OpenAI::StructuredOutput::ParsedJson
 
         # @!attribute call_id
         #   The unique ID of the function tool call generated by the model.

data/lib/openai/models/responses/response_input_file.rb

@@ -22,13 +22,19 @@ module OpenAI
         #   @return [String, nil]
         optional :file_id, String, nil?: true
 
+        # @!attribute file_url
+        #   The URL of the file to be sent to the model.
+        #
+        #   @return [String, nil]
+        optional :file_url, String
+
         # @!attribute filename
         #   The name of the file to be sent to the model.
         #
         #   @return [String, nil]
         optional :filename, String
 
-        # @!method initialize(file_data: nil, file_id: nil, filename: nil, type: :input_file)
+        # @!method initialize(file_data: nil, file_id: nil, file_url: nil, filename: nil, type: :input_file)
         #   Some parameter documentations has been truncated, see
         #   {OpenAI::Models::Responses::ResponseInputFile} for more details.
         #
@@ -38,6 +44,8 @@ module OpenAI
         #
         #   @param file_id [String, nil] The ID of the file to be sent to the model.
         #
+        #   @param file_url [String] The URL of the file to be sent to the model.
+        #
         #   @param filename [String] The name of the file to be sent to the model.
         #
         #   @param type [Symbol, :input_file] The type of the input item. Always `input_file`.

data/lib/openai/models/responses/response_mcp_call_arguments_delta_event.rb

@@ -29,12 +29,12 @@ module OpenAI
         required :sequence_number, Integer
 
         # @!attribute type
-        #   The type of the event. Always 'response.mcp_call.arguments_delta'.
+        #   The type of the event. Always 'response.mcp_call_arguments.delta'.
         #
-        #   @return [Symbol, :"response.mcp_call.arguments_delta"]
-        required :type, const: :"response.mcp_call.arguments_delta"
+        #   @return [Symbol, :"response.mcp_call_arguments.delta"]
+        required :type, const: :"response.mcp_call_arguments.delta"
 
-        # @!method initialize(delta:, item_id:, output_index:, sequence_number:, type: :"response.mcp_call.arguments_delta")
+        # @!method initialize(delta:, item_id:, output_index:, sequence_number:, type: :"response.mcp_call_arguments.delta")
         #   Emitted when there is a delta (partial update) to the arguments of an MCP tool
         #   call.
         #
@@ -46,7 +46,7 @@ module OpenAI
         #
         #   @param sequence_number [Integer] The sequence number of this event.
         #
-        #   @param type [Symbol, :"response.mcp_call.arguments_delta"] The type of the event. Always 'response.mcp_call.arguments_delta'.
+        #   @param type [Symbol, :"response.mcp_call_arguments.delta"] The type of the event. Always 'response.mcp_call_arguments.delta'.
       end
     end
   end

data/lib/openai/models/responses/response_mcp_call_arguments_done_event.rb

@@ -29,12 +29,12 @@ module OpenAI
         required :sequence_number, Integer
 
         # @!attribute type
-        #   The type of the event. Always 'response.mcp_call.arguments_done'.
+        #   The type of the event. Always 'response.mcp_call_arguments.done'.
         #
-        #   @return [Symbol, :"response.mcp_call.arguments_done"]
-        required :type, const: :"response.mcp_call.arguments_done"
+        #   @return [Symbol, :"response.mcp_call_arguments.done"]
+        required :type, const: :"response.mcp_call_arguments.done"
 
-        # @!method initialize(arguments:, item_id:, output_index:, sequence_number:, type: :"response.mcp_call.arguments_done")
+        # @!method initialize(arguments:, item_id:, output_index:, sequence_number:, type: :"response.mcp_call_arguments.done")
         #   Emitted when the arguments for an MCP tool call are finalized.
         #
         #   @param arguments [Object] The finalized arguments for the MCP tool call.
@@ -45,7 +45,7 @@ module OpenAI
         #
         #   @param sequence_number [Integer] The sequence number of this event.
         #
-        #   @param type [Symbol, :"response.mcp_call.arguments_done"] The type of the event. Always 'response.mcp_call.arguments_done'.
+        #   @param type [Symbol, :"response.mcp_call_arguments.done"] The type of the event. Always 'response.mcp_call_arguments.done'.
       end
     end
   end

data/lib/openai/models/responses/response_output_text.rb

@@ -23,7 +23,7 @@ module OpenAI
         #   The parsed contents of the output, if JSON schema is specified.
         #
         #   @return [Object, nil]
-        optional :parsed, OpenAI::Internal::Type::Unknown
+        optional :parsed, OpenAI::StructuredOutput::ParsedJson
 
         # @!attribute type
         #   The type of the output text. Always `output_text`.

data/lib/openai/models/responses/response_output_text_annotation_added_event.rb

@@ -41,12 +41,12 @@ module OpenAI
         required :sequence_number, Integer
 
         # @!attribute type
-        #   The type of the event. Always 'response.output_text_annotation.added'.
+        #   The type of the event. Always 'response.output_text.annotation.added'.
         #
-        #   @return [Symbol, :"response.output_text_annotation.added"]
-        required :type, const: :"response.output_text_annotation.added"
+        #   @return [Symbol, :"response.output_text.annotation.added"]
+        required :type, const: :"response.output_text.annotation.added"
 
-        # @!method initialize(annotation:, annotation_index:, content_index:, item_id:, output_index:, sequence_number:, type: :"response.output_text_annotation.added")
+        # @!method initialize(annotation:, annotation_index:, content_index:, item_id:, output_index:, sequence_number:, type: :"response.output_text.annotation.added")
         #   Emitted when an annotation is added to output text content.
         #
         #   @param annotation [Object] The annotation object being added. (See annotation schema for details.)
@@ -61,7 +61,7 @@ module OpenAI
         #
         #   @param sequence_number [Integer] The sequence number of this event.
         #
-        #   @param type [Symbol, :"response.output_text_annotation.added"] The type of the event. Always 'response.output_text_annotation.added'.
+        #   @param type [Symbol, :"response.output_text.annotation.added"] The type of the event. Always 'response.output_text.annotation.added'.
       end
     end
   end