openai 0.27.1 → 0.28.0

data/lib/openai/models.rb

@@ -63,6 +63,8 @@ module OpenAI
 
   BatchRetrieveParams = OpenAI::Models::BatchRetrieveParams
 
+  BatchUsage = OpenAI::Models::BatchUsage
+
   Beta = OpenAI::Models::Beta
 
   Chat = OpenAI::Models::Chat

data/lib/openai/version.rb

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

data/lib/openai.rb

@@ -99,6 +99,7 @@ require_relative "openai/models/batch_error"
 require_relative "openai/models/batch_list_params"
 require_relative "openai/models/batch_request_counts"
 require_relative "openai/models/batch_retrieve_params"
+require_relative "openai/models/batch_usage"
 require_relative "openai/models/beta/assistant"
 require_relative "openai/models/beta/assistant_create_params"
 require_relative "openai/models/beta/assistant_deleted"
@@ -537,6 +538,8 @@ require_relative "openai/models/responses/response_format_text_config"
 require_relative "openai/models/responses/response_format_text_json_schema_config"
 require_relative "openai/models/responses/response_function_call_arguments_delta_event"
 require_relative "openai/models/responses/response_function_call_arguments_done_event"
+require_relative "openai/models/responses/response_function_call_output_item"
+require_relative "openai/models/responses/response_function_call_output_item_list"
 require_relative "openai/models/responses/response_function_tool_call_item"
 require_relative "openai/models/responses/response_function_tool_call_output_item"
 require_relative "openai/models/responses/response_function_web_search"
@@ -550,9 +553,12 @@ require_relative "openai/models/responses/response_in_progress_event"
 require_relative "openai/models/responses/response_input"
 require_relative "openai/models/responses/response_input_audio"
 require_relative "openai/models/responses/response_input_content"
+require_relative "openai/models/responses/response_input_file_content"
+require_relative "openai/models/responses/response_input_image_content"
 require_relative "openai/models/responses/response_input_item"
 require_relative "openai/models/responses/response_input_message_content_list"
 require_relative "openai/models/responses/response_input_message_item"
+require_relative "openai/models/responses/response_input_text_content"
 require_relative "openai/models/responses/response_item"
 require_relative "openai/models/responses/response_item_list"
 require_relative "openai/models/responses/response_mcp_call_arguments_delta_event"

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

@@ -12,21 +12,6 @@ module OpenAI
         Message = type_member(:in)
         Elem = type_member(:out)
 
-        class << self
-          # Attempt to close the underlying transport when the stream itself is garbage
-          # collected.
-          #
-          # This should not be relied upon for resource clean up, as the garbage collector
-          # is not guaranteed to run.
-          sig do
-            params(stream: T::Enumerable[T.anything]).returns(
-              T.proc.params(arg0: Integer).void
-            )
-          end
-          def defer_closing(stream)
-          end
-        end
-
         sig { returns(Integer) }
         attr_reader :status
 

data/rbi/openai/models/batch.rbi

@@ -110,6 +110,17 @@ module OpenAI
       sig { returns(T.nilable(T::Hash[Symbol, String])) }
       attr_accessor :metadata
 
+      # Model ID used to process the batch, like `gpt-5-2025-08-07`. OpenAI offers a
+      # wide range of models with different capabilities, performance characteristics,
+      # and price points. Refer to the
+      # [model guide](https://platform.openai.com/docs/models) to browse and compare
+      # available models.
+      sig { returns(T.nilable(String)) }
+      attr_reader :model
+
+      sig { params(model: String).void }
+      attr_writer :model
+
       # The ID of the file containing the outputs of successfully executed requests.
       sig { returns(T.nilable(String)) }
       attr_reader :output_file_id
@@ -124,6 +135,15 @@ module OpenAI
       sig { params(request_counts: OpenAI::BatchRequestCounts::OrHash).void }
       attr_writer :request_counts
 
+      # Represents token usage details including input tokens, output tokens, a
+      # breakdown of output tokens, and the total tokens used. Only populated on batches
+      # created after September 7, 2025.
+      sig { returns(T.nilable(OpenAI::BatchUsage)) }
+      attr_reader :usage
+
+      sig { params(usage: OpenAI::BatchUsage::OrHash).void }
+      attr_writer :usage
+
       sig do
         params(
           id: String,
@@ -143,8 +163,10 @@ module OpenAI
           finalizing_at: Integer,
           in_progress_at: Integer,
           metadata: T.nilable(T::Hash[Symbol, String]),
+          model: String,
           output_file_id: String,
           request_counts: OpenAI::BatchRequestCounts::OrHash,
+          usage: OpenAI::BatchUsage::OrHash,
           object: Symbol
         ).returns(T.attached_class)
       end
@@ -186,10 +208,20 @@ module OpenAI
         # Keys are strings with a maximum length of 64 characters. Values are strings with
         # a maximum length of 512 characters.
         metadata: nil,
+        # Model ID used to process the batch, like `gpt-5-2025-08-07`. OpenAI offers a
+        # wide range of models with different capabilities, performance characteristics,
+        # and price points. Refer to the
+        # [model guide](https://platform.openai.com/docs/models) to browse and compare
+        # available models.
+        model: nil,
         # The ID of the file containing the outputs of successfully executed requests.
         output_file_id: nil,
         # The request counts for different statuses within the batch.
         request_counts: nil,
+        # Represents token usage details including input tokens, output tokens, a
+        # breakdown of output tokens, and the total tokens used. Only populated on batches
+        # created after September 7, 2025.
+        usage: nil,
         # The object type, which is always `batch`.
         object: :batch
       )
@@ -216,8 +248,10 @@ module OpenAI
             finalizing_at: Integer,
             in_progress_at: Integer,
             metadata: T.nilable(T::Hash[Symbol, String]),
+            model: String,
             output_file_id: String,
-            request_counts: OpenAI::BatchRequestCounts
+            request_counts: OpenAI::BatchRequestCounts,
+            usage: OpenAI::BatchUsage
           }
         )
       end

data/rbi/openai/models/batch_usage.rbi

@@ -0,0 +1,139 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    class BatchUsage < OpenAI::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias { T.any(OpenAI::BatchUsage, OpenAI::Internal::AnyHash) }
+
+      # The number of input tokens.
+      sig { returns(Integer) }
+      attr_accessor :input_tokens
+
+      # A detailed breakdown of the input tokens.
+      sig { returns(OpenAI::BatchUsage::InputTokensDetails) }
+      attr_reader :input_tokens_details
+
+      sig do
+        params(
+          input_tokens_details: OpenAI::BatchUsage::InputTokensDetails::OrHash
+        ).void
+      end
+      attr_writer :input_tokens_details
+
+      # The number of output tokens.
+      sig { returns(Integer) }
+      attr_accessor :output_tokens
+
+      # A detailed breakdown of the output tokens.
+      sig { returns(OpenAI::BatchUsage::OutputTokensDetails) }
+      attr_reader :output_tokens_details
+
+      sig do
+        params(
+          output_tokens_details: OpenAI::BatchUsage::OutputTokensDetails::OrHash
+        ).void
+      end
+      attr_writer :output_tokens_details
+
+      # The total number of tokens used.
+      sig { returns(Integer) }
+      attr_accessor :total_tokens
+
+      # Represents token usage details including input tokens, output tokens, a
+      # breakdown of output tokens, and the total tokens used. Only populated on batches
+      # created after September 7, 2025.
+      sig do
+        params(
+          input_tokens: Integer,
+          input_tokens_details: OpenAI::BatchUsage::InputTokensDetails::OrHash,
+          output_tokens: Integer,
+          output_tokens_details:
+            OpenAI::BatchUsage::OutputTokensDetails::OrHash,
+          total_tokens: Integer
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # The number of input tokens.
+        input_tokens:,
+        # A detailed breakdown of the input tokens.
+        input_tokens_details:,
+        # The number of output tokens.
+        output_tokens:,
+        # A detailed breakdown of the output tokens.
+        output_tokens_details:,
+        # The total number of tokens used.
+        total_tokens:
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            input_tokens: Integer,
+            input_tokens_details: OpenAI::BatchUsage::InputTokensDetails,
+            output_tokens: Integer,
+            output_tokens_details: OpenAI::BatchUsage::OutputTokensDetails,
+            total_tokens: Integer
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class InputTokensDetails < OpenAI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              OpenAI::BatchUsage::InputTokensDetails,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+        # The number of tokens that were retrieved from the cache.
+        # [More on prompt caching](https://platform.openai.com/docs/guides/prompt-caching).
+        sig { returns(Integer) }
+        attr_accessor :cached_tokens
+
+        # A detailed breakdown of the input tokens.
+        sig { params(cached_tokens: Integer).returns(T.attached_class) }
+        def self.new(
+          # The number of tokens that were retrieved from the cache.
+          # [More on prompt caching](https://platform.openai.com/docs/guides/prompt-caching).
+          cached_tokens:
+        )
+        end
+
+        sig { override.returns({ cached_tokens: Integer }) }
+        def to_hash
+        end
+      end
+
+      class OutputTokensDetails < OpenAI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              OpenAI::BatchUsage::OutputTokensDetails,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+        # The number of reasoning tokens.
+        sig { returns(Integer) }
+        attr_accessor :reasoning_tokens
+
+        # A detailed breakdown of the output tokens.
+        sig { params(reasoning_tokens: Integer).returns(T.attached_class) }
+        def self.new(
+          # The number of reasoning tokens.
+          reasoning_tokens:
+        )
+        end
+
+        sig { override.returns({ reasoning_tokens: Integer }) }
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/openai/models/responses/response_custom_tool_call_output.rbi

@@ -16,8 +16,13 @@ module OpenAI
         sig { returns(String) }
         attr_accessor :call_id
 
-        # The output from the custom tool call generated by your code.
-        sig { returns(String) }
+        # The output from the custom tool call generated by your code. Can be a string or
+        # an list of output content.
+        sig do
+          returns(
+            OpenAI::Responses::ResponseCustomToolCallOutput::Output::Variants
+          )
+        end
         attr_accessor :output
 
         # The type of the custom tool call output. Always `custom_tool_call_output`.
@@ -35,7 +40,8 @@ module OpenAI
         sig do
           params(
             call_id: String,
-            output: String,
+            output:
+              OpenAI::Responses::ResponseCustomToolCallOutput::Output::Variants,
             id: String,
             type: Symbol
           ).returns(T.attached_class)
@@ -43,7 +49,8 @@ module OpenAI
         def self.new(
           # The call ID, used to map this custom tool call output to a custom tool call.
           call_id:,
-          # The output from the custom tool call generated by your code.
+          # The output from the custom tool call generated by your code. Can be a string or
+          # an list of output content.
           output:,
           # The unique ID of the custom tool call output in the OpenAI platform.
           id: nil,
@@ -54,11 +61,76 @@ module OpenAI
 
         sig do
           override.returns(
-            { call_id: String, output: String, type: Symbol, id: String }
+            {
+              call_id: String,
+              output:
+                OpenAI::Responses::ResponseCustomToolCallOutput::Output::Variants,
+              type: Symbol,
+              id: String
+            }
           )
         end
         def to_hash
         end
+
+        # The output from the custom tool call generated by your code. Can be a string or
+        # an list of output content.
+        module Output
+          extend OpenAI::Internal::Type::Union
+
+          Variants =
+            T.type_alias do
+              T.any(
+                String,
+                T::Array[
+                  OpenAI::Responses::ResponseCustomToolCallOutput::Output::OutputContentList::Variants
+                ]
+              )
+            end
+
+          # A text input to the model.
+          module OutputContentList
+            extend OpenAI::Internal::Type::Union
+
+            Variants =
+              T.type_alias do
+                T.any(
+                  OpenAI::Responses::ResponseInputText,
+                  OpenAI::Responses::ResponseInputImage,
+                  OpenAI::Responses::ResponseInputFile
+                )
+              end
+
+            sig do
+              override.returns(
+                T::Array[
+                  OpenAI::Responses::ResponseCustomToolCallOutput::Output::OutputContentList::Variants
+                ]
+              )
+            end
+            def self.variants
+            end
+          end
+
+          sig do
+            override.returns(
+              T::Array[
+                OpenAI::Responses::ResponseCustomToolCallOutput::Output::Variants
+              ]
+            )
+          end
+          def self.variants
+          end
+
+          OutputContentListArray =
+            T.let(
+              OpenAI::Internal::Type::ArrayOf[
+                union:
+                  OpenAI::Responses::ResponseCustomToolCallOutput::Output::OutputContentList
+              ],
+              OpenAI::Internal::Type::Converter
+            )
+        end
       end
     end
   end

data/rbi/openai/models/responses/response_function_call_arguments_done_event.rbi

@@ -20,6 +20,10 @@ module OpenAI
         sig { returns(String) }
         attr_accessor :item_id
 
+        # The name of the function that was called.
+        sig { returns(String) }
+        attr_accessor :name
+
         # The index of the output item.
         sig { returns(Integer) }
         attr_accessor :output_index
@@ -36,6 +40,7 @@ module OpenAI
           params(
             arguments: String,
             item_id: String,
+            name: String,
             output_index: Integer,
             sequence_number: Integer,
             type: Symbol
@@ -46,6 +51,8 @@ module OpenAI
           arguments:,
           # The ID of the item.
           item_id:,
+          # The name of the function that was called.
+          name:,
           # The index of the output item.
           output_index:,
           # The sequence number of this event.
@@ -59,6 +66,7 @@ module OpenAI
             {
               arguments: String,
               item_id: String,
+              name: String,
               output_index: Integer,
               sequence_number: Integer,
               type: Symbol

data/rbi/openai/models/responses/response_function_call_output_item.rbi

@@ -0,0 +1,31 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    module Responses
+      # A text input to the model.
+      module ResponseFunctionCallOutputItem
+        extend OpenAI::Internal::Type::Union
+
+        Variants =
+          T.type_alias do
+            T.any(
+              OpenAI::Responses::ResponseInputTextContent,
+              OpenAI::Responses::ResponseInputImageContent,
+              OpenAI::Responses::ResponseInputFileContent
+            )
+          end
+
+        sig do
+          override.returns(
+            T::Array[
+              OpenAI::Responses::ResponseFunctionCallOutputItem::Variants
+            ]
+          )
+        end
+        def self.variants
+        end
+      end
+    end
+  end
+end

data/rbi/openai/models/responses/response_function_call_output_item_list.rbi

@@ -0,0 +1,15 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    module Responses
+      ResponseFunctionCallOutputItemList =
+        T.let(
+          OpenAI::Internal::Type::ArrayOf[
+            union: OpenAI::Responses::ResponseFunctionCallOutputItem
+          ],
+          OpenAI::Internal::Type::Converter
+        )
+    end
+  end
+end

data/rbi/openai/models/responses/response_function_tool_call_output_item.rbi

@@ -20,8 +20,13 @@ module OpenAI
         sig { returns(String) }
         attr_accessor :call_id
 
-        # A JSON string of the output of the function tool call.
-        sig { returns(String) }
+        # The output from the function call generated by your code. Can be a string or an
+        # list of output content.
+        sig do
+          returns(
+            OpenAI::Responses::ResponseFunctionToolCallOutputItem::Output::Variants
+          )
+        end
         attr_accessor :output
 
         # The type of the function tool call output. Always `function_call_output`.
@@ -51,7 +56,8 @@ module OpenAI
           params(
             id: String,
             call_id: String,
-            output: String,
+            output:
+              OpenAI::Responses::ResponseFunctionToolCallOutputItem::Output::Variants,
             status:
               OpenAI::Responses::ResponseFunctionToolCallOutputItem::Status::OrSymbol,
             type: Symbol
@@ -62,7 +68,8 @@ module OpenAI
           id:,
           # The unique ID of the function tool call generated by the model.
           call_id:,
-          # A JSON string of the output of the function tool call.
+          # The output from the function call generated by your code. Can be a string or an
+          # list of output content.
           output:,
           # The status of the item. One of `in_progress`, `completed`, or `incomplete`.
           # Populated when items are returned via API.
@@ -77,7 +84,8 @@ module OpenAI
             {
               id: String,
               call_id: String,
-              output: String,
+              output:
+                OpenAI::Responses::ResponseFunctionToolCallOutputItem::Output::Variants,
               type: Symbol,
               status:
                 OpenAI::Responses::ResponseFunctionToolCallOutputItem::Status::TaggedSymbol
@@ -87,6 +95,65 @@ module OpenAI
         def to_hash
         end
 
+        # The output from the function call generated by your code. Can be a string or an
+        # list of output content.
+        module Output
+          extend OpenAI::Internal::Type::Union
+
+          Variants =
+            T.type_alias do
+              T.any(
+                String,
+                T::Array[
+                  OpenAI::Responses::ResponseFunctionToolCallOutputItem::Output::OutputContentList::Variants
+                ]
+              )
+            end
+
+          # A text input to the model.
+          module OutputContentList
+            extend OpenAI::Internal::Type::Union
+
+            Variants =
+              T.type_alias do
+                T.any(
+                  OpenAI::Responses::ResponseInputText,
+                  OpenAI::Responses::ResponseInputImage,
+                  OpenAI::Responses::ResponseInputFile
+                )
+              end
+
+            sig do
+              override.returns(
+                T::Array[
+                  OpenAI::Responses::ResponseFunctionToolCallOutputItem::Output::OutputContentList::Variants
+                ]
+              )
+            end
+            def self.variants
+            end
+          end
+
+          sig do
+            override.returns(
+              T::Array[
+                OpenAI::Responses::ResponseFunctionToolCallOutputItem::Output::Variants
+              ]
+            )
+          end
+          def self.variants
+          end
+
+          OutputContentListArray =
+            T.let(
+              OpenAI::Internal::Type::ArrayOf[
+                union:
+                  OpenAI::Responses::ResponseFunctionToolCallOutputItem::Output::OutputContentList
+              ],
+              OpenAI::Internal::Type::Converter
+            )
+        end
+
         # The status of the item. One of `in_progress`, `completed`, or `incomplete`.
         # Populated when items are returned via API.
         module Status

data/rbi/openai/models/responses/response_input_file_content.rbi

@@ -0,0 +1,75 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    module Responses
+      class ResponseInputFileContent < OpenAI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              OpenAI::Responses::ResponseInputFileContent,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+        # The type of the input item. Always `input_file`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # The base64-encoded data of the file to be sent to the model.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :file_data
+
+        # The ID of the file to be sent to the model.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :file_id
+
+        # The URL of the file to be sent to the model.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :file_url
+
+        # The name of the file to be sent to the model.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :filename
+
+        # A file input to the model.
+        sig do
+          params(
+            file_data: T.nilable(String),
+            file_id: T.nilable(String),
+            file_url: T.nilable(String),
+            filename: T.nilable(String),
+            type: Symbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # The base64-encoded data of the file to be sent to the model.
+          file_data: nil,
+          # The ID of the file to be sent to the model.
+          file_id: nil,
+          # The URL of the file to be sent to the model.
+          file_url: nil,
+          # The name of the file to be sent to the model.
+          filename: nil,
+          # The type of the input item. Always `input_file`.
+          type: :input_file
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              type: Symbol,
+              file_data: T.nilable(String),
+              file_id: T.nilable(String),
+              file_url: T.nilable(String),
+              filename: T.nilable(String)
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end