openai 0.11.0 → 0.13.0

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

@@ -151,13 +151,13 @@ module OpenAI
                 -> { OpenAI::Responses::ResponseImageGenCallPartialImageEvent }
 
         # Emitted when there is a delta (partial update) to the arguments of an MCP tool call.
-        variant :"response.mcp_call.arguments_delta",
+        variant :"response.mcp_call_arguments.delta",
                 -> {
                   OpenAI::Responses::ResponseMcpCallArgumentsDeltaEvent
                 }
 
         # Emitted when the arguments for an MCP tool call are finalized.
-        variant :"response.mcp_call.arguments_done",
+        variant :"response.mcp_call_arguments.done",
                 -> {
                   OpenAI::Responses::ResponseMcpCallArgumentsDoneEvent
                 }
@@ -185,7 +185,7 @@ module OpenAI
                 -> { OpenAI::Responses::ResponseMcpListToolsInProgressEvent }
 
         # Emitted when an annotation is added to output text content.
-        variant :"response.output_text_annotation.added",
+        variant :"response.output_text.annotation.added",
                 -> { OpenAI::Responses::ResponseOutputTextAnnotationAddedEvent }
 
         # Emitted when a response is queued and waiting to be processed.

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

@@ -74,7 +74,13 @@ module OpenAI
           #   @return [OpenAI::Models::Responses::Tool::Mcp::RequireApproval::McpToolApprovalFilter, Symbol, OpenAI::Models::Responses::Tool::Mcp::RequireApproval::McpToolApprovalSetting, nil]
           optional :require_approval, union: -> { OpenAI::Responses::Tool::Mcp::RequireApproval }, nil?: true
 
-          # @!method initialize(server_label:, server_url:, allowed_tools: nil, headers: nil, require_approval: nil, type: :mcp)
+          # @!attribute server_description
+          #   Optional description of the MCP server, used to provide more context.
+          #
+          #   @return [String, nil]
+          optional :server_description, String
+
+          # @!method initialize(server_label:, server_url:, allowed_tools: nil, headers: nil, require_approval: nil, server_description: nil, type: :mcp)
           #   Some parameter documentations has been truncated, see
           #   {OpenAI::Models::Responses::Tool::Mcp} for more details.
           #
@@ -92,6 +98,8 @@ module OpenAI
           #
           #   @param require_approval [OpenAI::Models::Responses::Tool::Mcp::RequireApproval::McpToolApprovalFilter, Symbol, OpenAI::Models::Responses::Tool::Mcp::RequireApproval::McpToolApprovalSetting, nil] Specify which of the MCP server's tools require approval.
           #
+          #   @param server_description [String] Optional description of the MCP server, used to provide more context.
+          #
           #   @param type [Symbol, :mcp] The type of the MCP tool. Always `mcp`.
 
           # List of allowed tool names or a filter object.

data/lib/openai/resources/chat/completions.rb

@@ -104,7 +104,6 @@ module OpenAI
             raise ArgumentError.new(message)
           end
 
-          # rubocop:disable Layout/LineLength
           model = nil
           tool_models = {}
           case parsed
@@ -157,11 +156,16 @@ module OpenAI
           else
           end
 
+          # rubocop:disable Metrics/BlockLength
           unwrap = ->(raw) do
             if model.is_a?(OpenAI::StructuredOutput::JsonSchemaConverter)
               raw[:choices]&.each do |choice|
                 message = choice.fetch(:message)
-                parsed = JSON.parse(message.fetch(:content), symbolize_names: true)
+                begin
+                  parsed = JSON.parse(message.fetch(:content), symbolize_names: true)
+                rescue JSON::ParserError => e
+                  parsed = e
+                end
                 coerced = OpenAI::Internal::Type::Converter.coerce(model, parsed)
                 message.store(:parsed, coerced)
               end
@@ -171,7 +175,11 @@ module OpenAI
                 func = tool_call.fetch(:function)
                 next if (model = tool_models[func.fetch(:name)]).nil?
 
-                parsed = JSON.parse(func.fetch(:arguments), symbolize_names: true)
+                begin
+                  parsed = JSON.parse(func.fetch(:arguments), symbolize_names: true)
+                rescue JSON::ParserError => e
+                  parsed = e
+                end
                 coerced = OpenAI::Internal::Type::Converter.coerce(model, parsed)
                 func.store(:parsed, coerced)
               end
@@ -179,7 +187,7 @@ module OpenAI
 
             raw
           end
-          # rubocop:enable Layout/LineLength
+          # rubocop:enable Metrics/BlockLength
 
           @client.request(
             method: :post,

data/lib/openai/resources/responses.rb

@@ -81,81 +81,12 @@ module OpenAI
           raise ArgumentError.new(message)
         end
 
-        model = nil
-        tool_models = {}
-        case parsed
-        in {text: OpenAI::StructuredOutput::JsonSchemaConverter => model}
-          parsed.update(
-            text: {
-              format: {
-                type: :json_schema,
-                strict: true,
-                name: model.name.split("::").last,
-                schema: model.to_json_schema
-              }
-            }
-          )
-        in {text: {format: OpenAI::StructuredOutput::JsonSchemaConverter => model}}
-          parsed.fetch(:text).update(
-            format: {
-              type: :json_schema,
-              strict: true,
-              name: model.name.split("::").last,
-              schema: model.to_json_schema
-            }
-          )
-        in {text: {format: {type: :json_schema, schema: OpenAI::StructuredOutput::JsonSchemaConverter => model}}}
-          parsed.dig(:text, :format).store(:schema, model.to_json_schema)
-        in {tools: Array => tools}
-          mapped = tools.map do |tool|
-            case tool
-            in OpenAI::StructuredOutput::JsonSchemaConverter
-              name = tool.name.split("::").last
-              tool_models.store(name, tool)
-              {
-                type: :function,
-                strict: true,
-                name: name,
-                parameters: tool.to_json_schema
-              }
-            in {type: :function, parameters: OpenAI::StructuredOutput::JsonSchemaConverter => params}
-              func = tool.fetch(:function)
-              name = func[:name] ||= params.name.split("::").last
-              tool_models.store(name, params)
-              func.update(parameters: params.to_json_schema)
-              tool
-            else
-              tool
-            end
-          end
-          tools.replace(mapped)
-        else
-        end
+        model, tool_models = get_structured_output_models(parsed)
 
         unwrap = ->(raw) do
-          if model.is_a?(OpenAI::StructuredOutput::JsonSchemaConverter)
-            raw[:output]
-              &.flat_map do |output|
-                next [] unless output[:type] == "message"
-                output[:content].to_a
-              end
-              &.each do |content|
-                next unless content[:type] == "output_text"
-                parsed = JSON.parse(content.fetch(:text), symbolize_names: true)
-                coerced = OpenAI::Internal::Type::Converter.coerce(model, parsed)
-                content.store(:parsed, coerced)
-              end
-          end
-          raw[:output]&.each do |output|
-            next unless output[:type] == "function_call"
-            next if (model = tool_models[output.fetch(:name)]).nil?
-            parsed = JSON.parse(output.fetch(:arguments), symbolize_names: true)
-            coerced = OpenAI::Internal::Type::Converter.coerce(model, parsed)
-            output.store(:parsed, coerced)
-          end
-
-          raw
+          parse_structured_outputs!(raw, model, tool_models)
         end
+
         @client.request(
           method: :post,
           path: "responses",
@@ -166,8 +97,112 @@ module OpenAI
         )
       end
 
-      def stream
-        raise NotImplementedError.new("higher level helpers are coming soon!")
+      # See {OpenAI::Resources::Responses#create} for non-streaming counterpart.
+      #
+      # Some parameter documentations has been truncated, see
+      # {OpenAI::Models::Responses::ResponseCreateParams} for more details.
+      #
+      # Creates a model response. Provide
+      # [text](https://platform.openai.com/docs/guides/text) or
+      # [image](https://platform.openai.com/docs/guides/images) inputs to generate
+      # [text](https://platform.openai.com/docs/guides/text) or
+      # [JSON](https://platform.openai.com/docs/guides/structured-outputs) outputs. Have
+      # the model call your own
+      # [custom code](https://platform.openai.com/docs/guides/function-calling) or use
+      # built-in [tools](https://platform.openai.com/docs/guides/tools) like
+      # [web search](https://platform.openai.com/docs/guides/tools-web-search) or
+      # [file search](https://platform.openai.com/docs/guides/tools-file-search) to use
+      # your own data as input for the model's response.
+      #
+      # @overload stream_raw(input:, model:, background: nil, include: nil, instructions: nil, max_output_tokens: nil, metadata: nil, parallel_tool_calls: nil, previous_response_id: nil, prompt: nil, reasoning: nil, service_tier: nil, store: nil, temperature: nil, text: nil, tool_choice: nil, tools: nil, top_p: nil, truncation: nil, user: nil, request_options: {})
+      #
+      # @param input [String, Array<OpenAI::Models::Responses::EasyInputMessage, OpenAI::Models::Responses::ResponseInputItem::Message, OpenAI::Models::Responses::ResponseOutputMessage, OpenAI::Models::Responses::ResponseFileSearchToolCall, OpenAI::Models::Responses::ResponseComputerToolCall, OpenAI::Models::Responses::ResponseInputItem::ComputerCallOutput, OpenAI::Models::Responses::ResponseFunctionWebSearch, OpenAI::Models::Responses::ResponseFunctionToolCall, OpenAI::Models::Responses::ResponseInputItem::FunctionCallOutput, OpenAI::Models::Responses::ResponseReasoningItem, OpenAI::Models::Responses::ResponseInputItem::ImageGenerationCall, OpenAI::Models::Responses::ResponseCodeInterpreterToolCall, OpenAI::Models::Responses::ResponseInputItem::LocalShellCall, OpenAI::Models::Responses::ResponseInputItem::LocalShellCallOutput, OpenAI::Models::Responses::ResponseInputItem::McpListTools, OpenAI::Models::Responses::ResponseInputItem::McpApprovalRequest, OpenAI::Models::Responses::ResponseInputItem::McpApprovalResponse, OpenAI::Models::Responses::ResponseInputItem::McpCall, OpenAI::Models::Responses::ResponseInputItem::ItemReference>] Text, image, or file inputs to the model, used to generate a response.
+      #
+      # @param model [String, Symbol, OpenAI::Models::ChatModel, OpenAI::Models::ResponsesModel::ResponsesOnlyModel] Model ID used to generate the response, like `gpt-4o` or `o3`. OpenAI
+      #
+      # @param background [Boolean, nil] Whether to run the model response in the background.
+      #
+      # @param include [Array<Symbol, OpenAI::Models::Responses::ResponseIncludable>, nil] Specify additional output data to include in the model response. Currently
+      #
+      # @param instructions [String, nil] A system (or developer) message inserted into the model's context.
+      #
+      # @param max_output_tokens [Integer, nil] An upper bound for the number of tokens that can be generated for a response, in
+      #
+      # @param metadata [Hash{Symbol=>String}, nil] Set of 16 key-value pairs that can be attached to an object. This can be
+      #
+      # @param parallel_tool_calls [Boolean, nil] Whether to allow the model to run tool calls in parallel.
+      #
+      # @param previous_response_id [String, nil] The unique ID of the previous response to the model. Use this to resume streams from a given response.
+      #
+      # @param prompt [OpenAI::Models::Responses::ResponsePrompt, nil] Reference to a prompt template and its variables.
+      #
+      # @param reasoning [OpenAI::Models::Reasoning, nil] **o-series models only**
+      #
+      # @param service_tier [Symbol, OpenAI::Models::Responses::ResponseCreateParams::ServiceTier, nil] Specifies the latency tier to use for processing the request. This parameter is
+      #
+      # @param store [Boolean, nil] Whether to store the generated model response for later retrieval via
+      #
+      # @param temperature [Float, nil] What sampling temperature to use, between 0 and 2. Higher values like 0.8 will m
+      #
+      # @param text [OpenAI::Models::Responses::ResponseTextConfig] Configuration options for a text response from the model. Can be plain
+      #
+      # @param tool_choice [Symbol, OpenAI::Models::Responses::ToolChoiceOptions, OpenAI::Models::Responses::ToolChoiceTypes, OpenAI::Models::Responses::ToolChoiceFunction] How the model should select which tool (or tools) to use when generating
+      #
+      # @param tools [Array<OpenAI::Models::Responses::FunctionTool, OpenAI::Models::Responses::FileSearchTool, OpenAI::Models::Responses::ComputerTool, OpenAI::Models::Responses::Tool::Mcp, OpenAI::Models::Responses::Tool::CodeInterpreter, OpenAI::Models::Responses::Tool::ImageGeneration, OpenAI::Models::Responses::Tool::LocalShell, OpenAI::Models::Responses::WebSearchTool>] An array of tools the model may call while generating a response. You
+      #
+      # @param top_p [Float, nil] An alternative to sampling with temperature, called nucleus sampling,
+      #
+      # @param truncation [Symbol, OpenAI::Models::Responses::ResponseCreateParams::Truncation, nil] The truncation strategy to use for the model response.
+      #
+      # @param user [String] A stable identifier for your end-users.
+      #
+      # @param request_options [OpenAI::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [OpenAI::Helpers::Streaming::ResponseStream]
+      #
+      # @see OpenAI::Models::Responses::ResponseCreateParams
+      def stream(params)
+        parsed, options = OpenAI::Responses::ResponseCreateParams.dump_request(params)
+        starting_after, previous_response_id = parsed.values_at(:starting_after, :previous_response_id)
+
+        if starting_after && !previous_response_id
+          raise ArgumentError, "starting_after can only be used with previous_response_id"
+        end
+        model, tool_models = get_structured_output_models(parsed)
+
+        if previous_response_id
+          retrieve_params = {}
+          retrieve_params[:include] = params[:include] if params[:include]
+          retrieve_params[:request_options] = params[:request_options] if params[:request_options]
+
+          raw_stream = retrieve_streaming(previous_response_id, retrieve_params)
+        else
+          unwrap = ->(raw) do
+            if raw[:type] == "response.completed" && raw[:response]
+              parse_structured_outputs!(raw[:response], model, tool_models)
+            end
+            raw
+          end
+
+          parsed[:stream] = true
+
+          raw_stream = @client.request(
+            method: :post,
+            path: "responses",
+            headers: {"accept" => "text/event-stream"},
+            body: parsed,
+            stream: OpenAI::Internal::Stream,
+            model: OpenAI::Models::Responses::ResponseStreamEvent,
+            unwrap: unwrap,
+            options: options
+          )
+        end
+
+        OpenAI::Streaming::ResponseStream.new(
+          raw_stream: raw_stream,
+          text_format: model,
+          starting_after: starting_after
+        )
       end
 
       # See {OpenAI::Resources::Responses#create} for non-streaming counterpart.
@@ -207,7 +242,7 @@ module OpenAI
       #
       # @param parallel_tool_calls [Boolean, nil] Whether to allow the model to run tool calls in parallel.
       #
-      # @param previous_response_id [String, nil] The unique ID of the previous response to the model. Use this to
+      # @param previous_response_id [String, nil] The unique ID of the previous response to the response to the model. Use this to resume streams from a given response.
       #
       # @param prompt [OpenAI::Models::Responses::ResponsePrompt, nil] Reference to a prompt template and its variables.
       #
@@ -245,6 +280,7 @@ module OpenAI
           raise ArgumentError.new(message)
         end
         parsed.store(:stream, true)
+
         @client.request(
           method: :post,
           path: "responses",
@@ -378,6 +414,143 @@ module OpenAI
         @client = client
         @input_items = OpenAI::Resources::Responses::InputItems.new(client: client)
       end
+
+      private
+
+      # Post-processes raw API responses to parse and coerce structured outputs into typed Ruby objects.
+      #
+      # This method enhances the raw API response by parsing JSON content in structured outputs
+      # (both text outputs and function/tool calls) and converting them to their corresponding
+      # Ruby types using the JsonSchemaConverter models identified during request preparation.
+      #
+      # @param raw [Hash] The raw API response hash that will be mutated with parsed data
+      # @param model [JsonSchemaConverter|nil] The converter for structured text output, if specified
+      # @param tool_models [Hash<String, JsonSchemaConverter>] Hash mapping tool names to their converters
+      # @return [Hash] The mutated raw response with added :parsed fields containing typed Ruby objects
+      #
+      # The method performs two main transformations:
+      # 1. For structured text outputs: Finds output_text content, parses the JSON, and coerces it
+      #    to the model type, adding the result as content[:parsed]
+      # 2. For function/tool calls: Looks up the tool's converter by name, parses the arguments JSON,
+      #    and coerces it to the appropriate type, adding the result as output[:parsed]
+      def parse_structured_outputs!(raw, model, tool_models)
+        if model.is_a?(OpenAI::StructuredOutput::JsonSchemaConverter)
+          raw[:output]
+            &.flat_map do |output|
+              next [] unless output[:type] == "message"
+              output[:content].to_a
+            end
+            &.each do |content|
+              next unless content[:type] == "output_text"
+              begin
+                parsed = JSON.parse(content.fetch(:text), symbolize_names: true)
+              rescue JSON::ParserError => e
+                parsed = e
+              end
+              coerced = OpenAI::Internal::Type::Converter.coerce(model, parsed)
+              content.store(:parsed, coerced)
+            end
+        end
+        raw[:output]&.each do |output|
+          next unless output[:type] == "function_call"
+          next if (model = tool_models[output.fetch(:name)]).nil?
+          begin
+            parsed = JSON.parse(output.fetch(:arguments), symbolize_names: true)
+          rescue JSON::ParserError => e
+            parsed = e
+          end
+          coerced = OpenAI::Internal::Type::Converter.coerce(model, parsed)
+          output.store(:parsed, coerced)
+        end
+
+        raw
+      end
+
+      # Extracts structured output models from request parameters and converts them to JSON Schema format.
+      #
+      # This method processes the parsed request parameters to identify any JsonSchemaConverter instances
+      # that define expected output schemas. It transforms these Ruby schema definitions into the JSON
+      # Schema format required by the OpenAI API, enabling type-safe structured outputs.
+      #
+      # @param parsed [Hash] The parsed request parameters that may contain structured output definitions
+      # @return [Array<(JsonSchemaConverter|nil, Hash)>] A tuple containing:
+      #   - model: The JsonSchemaConverter for structured text output (or nil if not specified)
+      #   - tool_models: Hash mapping tool names to their JsonSchemaConverter models
+      #
+      # The method handles multiple ways structured outputs can be specified:
+      # - Direct text format: { text: JsonSchemaConverter }
+      # - Nested text format: { text: { format: JsonSchemaConverter } }
+      # - Deep nested format: { text: { format: { type: :json_schema, schema: JsonSchemaConverter } } }
+      # - Tool parameters: { tools: [JsonSchemaConverter, ...] } or tools with parameters as converters
+      def get_structured_output_models(parsed)
+        model = nil
+        tool_models = {}
+
+        case parsed
+        in {text: OpenAI::StructuredOutput::JsonSchemaConverter => model}
+          parsed.update(
+            text: {
+              format: {
+                type: :json_schema,
+                strict: true,
+                name: model.name.split("::").last,
+                schema: model.to_json_schema
+              }
+            }
+          )
+        in {text: {format: OpenAI::StructuredOutput::JsonSchemaConverter => model}}
+          parsed.fetch(:text).update(
+            format: {
+              type: :json_schema,
+              strict: true,
+              name: model.name.split("::").last,
+              schema: model.to_json_schema
+            }
+          )
+        in {text: {format: {type: :json_schema,
+                            schema: OpenAI::StructuredOutput::JsonSchemaConverter => model}}}
+          parsed.dig(:text, :format).store(:schema, model.to_json_schema)
+        in {tools: Array => tools}
+          # rubocop:disable Metrics/BlockLength
+          mapped = tools.map do |tool|
+            case tool
+            in OpenAI::StructuredOutput::JsonSchemaConverter
+              name = tool.name.split("::").last
+              tool_models.store(name, tool)
+              {
+                type: :function,
+                strict: true,
+                name: name,
+                parameters: tool.to_json_schema
+              }
+            in {type: :function, parameters: OpenAI::StructuredOutput::JsonSchemaConverter => params}
+              func = tool.fetch(:function)
+              name = func[:name] ||= params.name.split("::").last
+              tool_models.store(name, params)
+              func.update(parameters: params.to_json_schema)
+              tool
+            in {type: _, function: {parameters: OpenAI::StructuredOutput::JsonSchemaConverter => params, **}}
+              name = tool[:function][:name] || params.name.split("::").last
+              tool_models.store(name, params)
+              tool[:function][:parameters] = params.to_json_schema
+              tool
+            in {type: _, function: Hash => func} if func[:parameters].is_a?(Class) && func[:parameters] < OpenAI::Internal::Type::BaseModel
+              params = func[:parameters]
+              name = func[:name] || params.name.split("::").last
+              tool_models.store(name, params)
+              func[:parameters] = params.to_json_schema
+              tool
+            else
+              tool
+            end
+          end
+          # rubocop:enable Metrics/BlockLength
+          tools.replace(mapped)
+        else
+        end
+
+        [model, tool_models]
+      end
     end
   end
 end

data/lib/openai/streaming.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module OpenAI
+  Streaming = Helpers::Streaming
+end

data/lib/openai/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module OpenAI
-  VERSION = "0.11.0"
+  VERSION = "0.13.0"
 end

data/lib/openai.rb

@@ -56,6 +56,7 @@ require_relative "openai/helpers/structured_output/enum_of"
 require_relative "openai/helpers/structured_output/union_of"
 require_relative "openai/helpers/structured_output/array_of"
 require_relative "openai/helpers/structured_output/base_model"
+require_relative "openai/helpers/structured_output/parsed_json"
 require_relative "openai/helpers/structured_output"
 require_relative "openai/structured_output"
 require_relative "openai/models/reasoning_effort"
@@ -539,3 +540,6 @@ require_relative "openai/resources/vector_stores"
 require_relative "openai/resources/vector_stores/file_batches"
 require_relative "openai/resources/vector_stores/files"
 require_relative "openai/resources/webhooks"
+require_relative "openai/helpers/streaming/events"
+require_relative "openai/helpers/streaming/response_stream"
+require_relative "openai/streaming"

data/rbi/openai/helpers/streaming/events.rbi

@@ -0,0 +1,31 @@
+# typed: strong
+
+module OpenAI
+  module Helpers
+    module Streaming
+      class ResponseTextDeltaEvent < OpenAI::Models::Responses::ResponseTextDeltaEvent
+        sig { returns(String) }
+        def snapshot
+        end
+      end
+
+      class ResponseTextDoneEvent < OpenAI::Models::Responses::ResponseTextDoneEvent
+        sig { returns(T.untyped) }
+        def parsed
+        end
+      end
+
+      class ResponseFunctionCallArgumentsDeltaEvent < OpenAI::Models::Responses::ResponseFunctionCallArgumentsDeltaEvent
+        sig { returns(String) }
+        def snapshot
+        end
+      end
+
+      class ResponseCompletedEvent < OpenAI::Models::Responses::ResponseCompletedEvent
+        sig { returns(OpenAI::Models::Responses::Response) }
+        def response
+        end
+      end
+    end
+  end
+end

data/rbi/openai/helpers/streaming/response_stream.rbi

@@ -0,0 +1,104 @@
+# typed: strong
+
+module OpenAI
+  module Helpers
+    module Streaming
+      class ResponseStream
+        include OpenAI::Internal::Type::BaseStream
+
+        # Define the type union for streaming events that can be yielded
+        ResponseStreamEvent =
+          T.type_alias do
+            T.any(
+              OpenAI::Streaming::ResponseTextDeltaEvent,
+              OpenAI::Streaming::ResponseTextDoneEvent,
+              OpenAI::Streaming::ResponseCompletedEvent,
+              OpenAI::Streaming::ResponseFunctionCallArgumentsDeltaEvent,
+              # Pass through other raw events
+              OpenAI::Models::Responses::ResponseStreamEvent::Variants
+            )
+          end
+
+        Message = type_member { { fixed: ResponseStreamEvent } }
+        Elem = type_member { { fixed: ResponseStreamEvent } }
+
+        sig do
+          params(
+            raw_stream: T.untyped,
+            text_format: T.untyped,
+            starting_after: T.nilable(Integer)
+          ).void
+        end
+        def initialize(raw_stream:, text_format:, starting_after:)
+        end
+
+        sig { void }
+        def close
+        end
+
+        sig { returns(T.self_type) }
+        def until_done
+        end
+
+        sig { returns(OpenAI::Models::Responses::Response) }
+        def get_final_response
+        end
+
+        sig { returns(String) }
+        def get_output_text
+        end
+
+        sig { returns(T::Enumerator::Lazy[String]) }
+        def text
+        end
+
+        # Override the each method to properly type the yielded events
+        sig do
+          params(
+            block: T.nilable(T.proc.params(event: ResponseStreamEvent).void)
+          ).returns(T.any(T.self_type, T::Enumerator[ResponseStreamEvent]))
+        end
+        def each(&block)
+        end
+
+        private
+
+        sig { returns(T.untyped) }
+        def iterator
+        end
+      end
+
+      class ResponseStreamState
+        sig { returns(T.nilable(OpenAI::Models::Responses::Response)) }
+        attr_reader :completed_response
+
+        sig { params(text_format: T.untyped).void }
+        def initialize(text_format:)
+        end
+
+        sig { params(event: T.untyped).returns(T::Array[T.untyped]) }
+        def handle_event(event)
+        end
+
+        sig do
+          params(
+            event: T.untyped,
+            current_snapshot: T.nilable(OpenAI::Models::Responses::Response)
+          ).returns(OpenAI::Models::Responses::Response)
+        end
+        def accumulate_event(event:, current_snapshot:)
+        end
+
+        private
+
+        sig { params(text: T.nilable(String)).returns(T.untyped) }
+        def parse_structured_text(text)
+        end
+
+        sig { params(object: T.untyped, expected_type: Symbol).void }
+        def assert_type(object, expected_type)
+        end
+      end
+    end
+  end
+end

data/rbi/openai/internal/type/base_stream.rbi

@@ -52,10 +52,17 @@ module OpenAI
             url: URI::Generic,
             status: Integer,
             response: Net::HTTPResponse,
+            unwrap:
+              T.any(
+                Symbol,
+                Integer,
+                T::Array[T.any(Symbol, Integer)],
+                T.proc.params(arg0: T.anything).returns(T.anything)
+              ),
             stream: T::Enumerable[Message]
           ).void
         end
-        def initialize(model:, url:, status:, response:, stream:)
+        def initialize(model:, url:, status:, response:, unwrap:, stream:)
         end
 
         # @api private

data/rbi/openai/models/audio/transcription.rbi

@@ -291,7 +291,7 @@ module OpenAI
 
             # Duration of the input audio in seconds.
             sig { returns(Float) }
-            attr_accessor :duration
+            attr_accessor :seconds
 
             # The type of the usage object. Always `duration` for this variant.
             sig { returns(Symbol) }
@@ -299,17 +299,17 @@ module OpenAI
 
             # Usage statistics for models billed by audio input duration.
             sig do
-              params(duration: Float, type: Symbol).returns(T.attached_class)
+              params(seconds: Float, type: Symbol).returns(T.attached_class)
             end
             def self.new(
               # Duration of the input audio in seconds.
-              duration:,
+              seconds:,
               # The type of the usage object. Always `duration` for this variant.
               type: :duration
             )
             end
 
-            sig { override.returns({ duration: Float, type: Symbol }) }
+            sig { override.returns({ seconds: Float, type: Symbol }) }
             def to_hash
             end
           end