openai 0.34.1 → 0.35.0

data/rbi/openai/models/responses/file_search_tool.rbi

@@ -125,6 +125,25 @@ module OpenAI
               )
             end
 
+          # Weights that control how reciprocal rank fusion balances semantic embedding
+          # matches versus sparse keyword matches when hybrid search is enabled.
+          sig do
+            returns(
+              T.nilable(
+                OpenAI::Responses::FileSearchTool::RankingOptions::HybridSearch
+              )
+            )
+          end
+          attr_reader :hybrid_search
+
+          sig do
+            params(
+              hybrid_search:
+                OpenAI::Responses::FileSearchTool::RankingOptions::HybridSearch::OrHash
+            ).void
+          end
+          attr_writer :hybrid_search
+
           # The ranker to use for the file search.
           sig do
             returns(
@@ -155,12 +174,17 @@ module OpenAI
           # Ranking options for search.
           sig do
             params(
+              hybrid_search:
+                OpenAI::Responses::FileSearchTool::RankingOptions::HybridSearch::OrHash,
               ranker:
                 OpenAI::Responses::FileSearchTool::RankingOptions::Ranker::OrSymbol,
               score_threshold: Float
             ).returns(T.attached_class)
           end
           def self.new(
+            # Weights that control how reciprocal rank fusion balances semantic embedding
+            # matches versus sparse keyword matches when hybrid search is enabled.
+            hybrid_search: nil,
             # The ranker to use for the file search.
             ranker: nil,
             # The score threshold for the file search, a number between 0 and 1. Numbers
@@ -173,6 +197,8 @@ module OpenAI
           sig do
             override.returns(
               {
+                hybrid_search:
+                  OpenAI::Responses::FileSearchTool::RankingOptions::HybridSearch,
                 ranker:
                   OpenAI::Responses::FileSearchTool::RankingOptions::Ranker::OrSymbol,
                 score_threshold: Float
@@ -182,6 +208,45 @@ module OpenAI
           def to_hash
           end
 
+          class HybridSearch < OpenAI::Internal::Type::BaseModel
+            OrHash =
+              T.type_alias do
+                T.any(
+                  OpenAI::Responses::FileSearchTool::RankingOptions::HybridSearch,
+                  OpenAI::Internal::AnyHash
+                )
+              end
+
+            # The weight of the embedding in the reciprocal ranking fusion.
+            sig { returns(Float) }
+            attr_accessor :embedding_weight
+
+            # The weight of the text in the reciprocal ranking fusion.
+            sig { returns(Float) }
+            attr_accessor :text_weight
+
+            # Weights that control how reciprocal rank fusion balances semantic embedding
+            # matches versus sparse keyword matches when hybrid search is enabled.
+            sig do
+              params(embedding_weight: Float, text_weight: Float).returns(
+                T.attached_class
+              )
+            end
+            def self.new(
+              # The weight of the embedding in the reciprocal ranking fusion.
+              embedding_weight:,
+              # The weight of the text in the reciprocal ranking fusion.
+              text_weight:
+            )
+            end
+
+            sig do
+              override.returns({ embedding_weight: Float, text_weight: Float })
+            end
+            def to_hash
+            end
+          end
+
           # The ranker to use for the file search.
           module Ranker
             extend OpenAI::Internal::Type::Enum

data/rbi/openai/models/responses/response_content.rbi

@@ -13,7 +13,6 @@ module OpenAI
               OpenAI::Responses::ResponseInputText,
               OpenAI::Responses::ResponseInputImage,
               OpenAI::Responses::ResponseInputFile,
-              OpenAI::Responses::ResponseInputAudio,
               OpenAI::Responses::ResponseOutputText,
               OpenAI::Responses::ResponseOutputRefusal,
               OpenAI::Responses::ResponseContent::ReasoningTextContent

data/rbi/openai/models/responses/response_input_content.rbi

@@ -12,8 +12,7 @@ module OpenAI
             T.any(
               OpenAI::Responses::ResponseInputText,
               OpenAI::Responses::ResponseInputImage,
-              OpenAI::Responses::ResponseInputFile,
-              OpenAI::Responses::ResponseInputAudio
+              OpenAI::Responses::ResponseInputFile
             )
           end
 

data/rbi/openai/models/responses/response_input_item.rbi

@@ -55,8 +55,7 @@ module OpenAI
                 T.any(
                   OpenAI::Responses::ResponseInputText,
                   OpenAI::Responses::ResponseInputImage,
-                  OpenAI::Responses::ResponseInputFile,
-                  OpenAI::Responses::ResponseInputAudio
+                  OpenAI::Responses::ResponseInputFile
                 )
               ]
             )
@@ -118,8 +117,7 @@ module OpenAI
                   T.any(
                     OpenAI::Responses::ResponseInputText::OrHash,
                     OpenAI::Responses::ResponseInputImage::OrHash,
-                    OpenAI::Responses::ResponseInputFile::OrHash,
-                    OpenAI::Responses::ResponseInputAudio::OrHash
+                    OpenAI::Responses::ResponseInputFile::OrHash
                   )
                 ],
               role:
@@ -152,8 +150,7 @@ module OpenAI
                     T.any(
                       OpenAI::Responses::ResponseInputText,
                       OpenAI::Responses::ResponseInputImage,
-                      OpenAI::Responses::ResponseInputFile,
-                      OpenAI::Responses::ResponseInputAudio
+                      OpenAI::Responses::ResponseInputFile
                     )
                   ],
                 role:

data/rbi/openai/models/responses/response_input_message_item.rbi

@@ -75,8 +75,7 @@ module OpenAI
                 T.any(
                   OpenAI::Responses::ResponseInputText::OrHash,
                   OpenAI::Responses::ResponseInputImage::OrHash,
-                  OpenAI::Responses::ResponseInputFile::OrHash,
-                  OpenAI::Responses::ResponseInputAudio::OrHash
+                  OpenAI::Responses::ResponseInputFile::OrHash
                 )
               ],
             role: OpenAI::Responses::ResponseInputMessageItem::Role::OrSymbol,

data/rbi/openai/models/responses/response_output_text.rbi

@@ -27,6 +27,11 @@ module OpenAI
         end
         attr_accessor :annotations
 
+        sig do
+          returns(T::Array[OpenAI::Responses::ResponseOutputText::Logprob])
+        end
+        attr_accessor :logprobs
+
         # The text output from the model.
         sig { returns(String) }
         attr_accessor :text
@@ -39,21 +44,6 @@ module OpenAI
         sig { returns(Symbol) }
         attr_accessor :type
 
-        sig do
-          returns(
-            T.nilable(T::Array[OpenAI::Responses::ResponseOutputText::Logprob])
-          )
-        end
-        attr_reader :logprobs
-
-        sig do
-          params(
-            logprobs:
-              T::Array[OpenAI::Responses::ResponseOutputText::Logprob::OrHash]
-          ).void
-        end
-        attr_writer :logprobs
-
         # A text output from the model.
         sig do
           params(
@@ -66,18 +56,18 @@ module OpenAI
                   OpenAI::Responses::ResponseOutputText::Annotation::FilePath::OrHash
                 )
               ],
-            text: String,
             logprobs:
               T::Array[OpenAI::Responses::ResponseOutputText::Logprob::OrHash],
+            text: String,
             type: Symbol
           ).returns(T.attached_class)
         end
         def self.new(
           # The annotations of the text output.
           annotations:,
+          logprobs:,
           # The text output from the model.
           text:,
-          logprobs: nil,
           # The type of the output text. Always `output_text`.
           type: :output_text
         )
@@ -95,9 +85,10 @@ module OpenAI
                     OpenAI::Responses::ResponseOutputText::Annotation::FilePath
                   )
                 ],
+              logprobs:
+                T::Array[OpenAI::Responses::ResponseOutputText::Logprob],
               text: String,
-              type: Symbol,
-              logprobs: T::Array[OpenAI::Responses::ResponseOutputText::Logprob]
+              type: Symbol
             }
           )
         end

data/rbi/openai/models/responses/tool.rbi

@@ -713,26 +713,94 @@ module OpenAI
               sig { params(file_ids: T::Array[String]).void }
               attr_writer :file_ids
 
+              sig do
+                returns(
+                  T.nilable(
+                    OpenAI::Responses::Tool::CodeInterpreter::Container::CodeInterpreterToolAuto::MemoryLimit::OrSymbol
+                  )
+                )
+              end
+              attr_accessor :memory_limit
+
               # Configuration for a code interpreter container. Optionally specify the IDs of
               # the files to run the code on.
               sig do
-                params(file_ids: T::Array[String], type: Symbol).returns(
-                  T.attached_class
-                )
+                params(
+                  file_ids: T::Array[String],
+                  memory_limit:
+                    T.nilable(
+                      OpenAI::Responses::Tool::CodeInterpreter::Container::CodeInterpreterToolAuto::MemoryLimit::OrSymbol
+                    ),
+                  type: Symbol
+                ).returns(T.attached_class)
               end
               def self.new(
                 # An optional list of uploaded files to make available to your code.
                 file_ids: nil,
+                memory_limit: nil,
                 # Always `auto`.
                 type: :auto
               )
               end
 
               sig do
-                override.returns({ type: Symbol, file_ids: T::Array[String] })
+                override.returns(
+                  {
+                    type: Symbol,
+                    file_ids: T::Array[String],
+                    memory_limit:
+                      T.nilable(
+                        OpenAI::Responses::Tool::CodeInterpreter::Container::CodeInterpreterToolAuto::MemoryLimit::OrSymbol
+                      )
+                  }
+                )
               end
               def to_hash
               end
+
+              module MemoryLimit
+                extend OpenAI::Internal::Type::Enum
+
+                TaggedSymbol =
+                  T.type_alias do
+                    T.all(
+                      Symbol,
+                      OpenAI::Responses::Tool::CodeInterpreter::Container::CodeInterpreterToolAuto::MemoryLimit
+                    )
+                  end
+                OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+                MEMORY_LIMIT_1G =
+                  T.let(
+                    :"1g",
+                    OpenAI::Responses::Tool::CodeInterpreter::Container::CodeInterpreterToolAuto::MemoryLimit::TaggedSymbol
+                  )
+                MEMORY_LIMIT_4G =
+                  T.let(
+                    :"4g",
+                    OpenAI::Responses::Tool::CodeInterpreter::Container::CodeInterpreterToolAuto::MemoryLimit::TaggedSymbol
+                  )
+                MEMORY_LIMIT_16G =
+                  T.let(
+                    :"16g",
+                    OpenAI::Responses::Tool::CodeInterpreter::Container::CodeInterpreterToolAuto::MemoryLimit::TaggedSymbol
+                  )
+                MEMORY_LIMIT_64G =
+                  T.let(
+                    :"64g",
+                    OpenAI::Responses::Tool::CodeInterpreter::Container::CodeInterpreterToolAuto::MemoryLimit::TaggedSymbol
+                  )
+
+                sig do
+                  override.returns(
+                    T::Array[
+                      OpenAI::Responses::Tool::CodeInterpreter::Container::CodeInterpreterToolAuto::MemoryLimit::TaggedSymbol
+                    ]
+                  )
+                end
+                def self.values
+                end
+              end
             end
 
             sig do
@@ -1335,6 +1403,7 @@ module OpenAI
           sig { returns(Symbol) }
           attr_accessor :type
 
+          # A tool that allows the model to execute shell commands in a local environment.
           sig { params(type: Symbol).returns(T.attached_class) }
           def self.new(
             # The type of the local shell tool. Always `local_shell`.

data/rbi/openai/models/vector_stores/file_batch_create_params.rbi

@@ -15,12 +15,6 @@ module OpenAI
             )
           end
 
-        # A list of [File](https://platform.openai.com/docs/api-reference/files) IDs that
-        # the vector store should use. Useful for tools like `file_search` that can access
-        # files.
-        sig { returns(T::Array[String]) }
-        attr_accessor :file_ids
-
         # Set of 16 key-value pairs that can be attached to an object. This can be useful
         # for storing additional information about the object in a structured format, and
         # querying for objects via API or the dashboard. Keys are strings with a maximum
@@ -63,9 +57,41 @@ module OpenAI
         end
         attr_writer :chunking_strategy
 
+        # A list of [File](https://platform.openai.com/docs/api-reference/files) IDs that
+        # the vector store should use. Useful for tools like `file_search` that can access
+        # files. If `attributes` or `chunking_strategy` are provided, they will be applied
+        # to all files in the batch. Mutually exclusive with `files`.
+        sig { returns(T.nilable(T::Array[String])) }
+        attr_reader :file_ids
+
+        sig { params(file_ids: T::Array[String]).void }
+        attr_writer :file_ids
+
+        # A list of objects that each include a `file_id` plus optional `attributes` or
+        # `chunking_strategy`. Use this when you need to override metadata for specific
+        # files. The global `attributes` or `chunking_strategy` will be ignored and must
+        # be specified for each file. Mutually exclusive with `file_ids`.
+        sig do
+          returns(
+            T.nilable(
+              T::Array[OpenAI::VectorStores::FileBatchCreateParams::File]
+            )
+          )
+        end
+        attr_reader :files
+
+        sig do
+          params(
+            files:
+              T::Array[
+                OpenAI::VectorStores::FileBatchCreateParams::File::OrHash
+              ]
+          ).void
+        end
+        attr_writer :files
+
         sig do
           params(
-            file_ids: T::Array[String],
             attributes:
               T.nilable(
                 T::Hash[
@@ -78,14 +104,15 @@ module OpenAI
                 OpenAI::AutoFileChunkingStrategyParam::OrHash,
                 OpenAI::StaticFileChunkingStrategyObjectParam::OrHash
               ),
+            file_ids: T::Array[String],
+            files:
+              T::Array[
+                OpenAI::VectorStores::FileBatchCreateParams::File::OrHash
+              ],
             request_options: OpenAI::RequestOptions::OrHash
           ).returns(T.attached_class)
         end
         def self.new(
-          # A list of [File](https://platform.openai.com/docs/api-reference/files) IDs that
-          # the vector store should use. Useful for tools like `file_search` that can access
-          # files.
-          file_ids:,
           # Set of 16 key-value pairs that can be attached to an object. This can be useful
           # for storing additional information about the object in a structured format, and
           # querying for objects via API or the dashboard. Keys are strings with a maximum
@@ -95,6 +122,16 @@ module OpenAI
           # The chunking strategy used to chunk the file(s). If not set, will use the `auto`
           # strategy. Only applicable if `file_ids` is non-empty.
           chunking_strategy: nil,
+          # A list of [File](https://platform.openai.com/docs/api-reference/files) IDs that
+          # the vector store should use. Useful for tools like `file_search` that can access
+          # files. If `attributes` or `chunking_strategy` are provided, they will be applied
+          # to all files in the batch. Mutually exclusive with `files`.
+          file_ids: nil,
+          # A list of objects that each include a `file_id` plus optional `attributes` or
+          # `chunking_strategy`. Use this when you need to override metadata for specific
+          # files. The global `attributes` or `chunking_strategy` will be ignored and must
+          # be specified for each file. Mutually exclusive with `file_ids`.
+          files: nil,
           request_options: {}
         )
         end
@@ -102,7 +139,6 @@ module OpenAI
         sig do
           override.returns(
             {
-              file_ids: T::Array[String],
               attributes:
                 T.nilable(
                   T::Hash[
@@ -115,6 +151,9 @@ module OpenAI
                   OpenAI::AutoFileChunkingStrategyParam,
                   OpenAI::StaticFileChunkingStrategyObjectParam
                 ),
+              file_ids: T::Array[String],
+              files:
+                T::Array[OpenAI::VectorStores::FileBatchCreateParams::File],
               request_options: OpenAI::RequestOptions
             }
           )
@@ -137,6 +176,136 @@ module OpenAI
           def self.variants
           end
         end
+
+        class File < OpenAI::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                OpenAI::VectorStores::FileBatchCreateParams::File,
+                OpenAI::Internal::AnyHash
+              )
+            end
+
+          # A [File](https://platform.openai.com/docs/api-reference/files) ID that the
+          # vector store should use. Useful for tools like `file_search` that can access
+          # files.
+          sig { returns(String) }
+          attr_accessor :file_id
+
+          # Set of 16 key-value pairs that can be attached to an object. This can be useful
+          # for storing additional information about the object in a structured format, and
+          # querying for objects via API or the dashboard. Keys are strings with a maximum
+          # length of 64 characters. Values are strings with a maximum length of 512
+          # characters, booleans, or numbers.
+          sig do
+            returns(
+              T.nilable(
+                T::Hash[
+                  Symbol,
+                  OpenAI::VectorStores::FileBatchCreateParams::File::Attribute::Variants
+                ]
+              )
+            )
+          end
+          attr_accessor :attributes
+
+          # The chunking strategy used to chunk the file(s). If not set, will use the `auto`
+          # strategy. Only applicable if `file_ids` is non-empty.
+          sig do
+            returns(
+              T.nilable(
+                T.any(
+                  OpenAI::AutoFileChunkingStrategyParam,
+                  OpenAI::StaticFileChunkingStrategyObjectParam
+                )
+              )
+            )
+          end
+          attr_reader :chunking_strategy
+
+          sig do
+            params(
+              chunking_strategy:
+                T.any(
+                  OpenAI::AutoFileChunkingStrategyParam::OrHash,
+                  OpenAI::StaticFileChunkingStrategyObjectParam::OrHash
+                )
+            ).void
+          end
+          attr_writer :chunking_strategy
+
+          sig do
+            params(
+              file_id: String,
+              attributes:
+                T.nilable(
+                  T::Hash[
+                    Symbol,
+                    OpenAI::VectorStores::FileBatchCreateParams::File::Attribute::Variants
+                  ]
+                ),
+              chunking_strategy:
+                T.any(
+                  OpenAI::AutoFileChunkingStrategyParam::OrHash,
+                  OpenAI::StaticFileChunkingStrategyObjectParam::OrHash
+                )
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            # A [File](https://platform.openai.com/docs/api-reference/files) ID that the
+            # vector store should use. Useful for tools like `file_search` that can access
+            # files.
+            file_id:,
+            # Set of 16 key-value pairs that can be attached to an object. This can be useful
+            # for storing additional information about the object in a structured format, and
+            # querying for objects via API or the dashboard. Keys are strings with a maximum
+            # length of 64 characters. Values are strings with a maximum length of 512
+            # characters, booleans, or numbers.
+            attributes: nil,
+            # The chunking strategy used to chunk the file(s). If not set, will use the `auto`
+            # strategy. Only applicable if `file_ids` is non-empty.
+            chunking_strategy: nil
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                file_id: String,
+                attributes:
+                  T.nilable(
+                    T::Hash[
+                      Symbol,
+                      OpenAI::VectorStores::FileBatchCreateParams::File::Attribute::Variants
+                    ]
+                  ),
+                chunking_strategy:
+                  T.any(
+                    OpenAI::AutoFileChunkingStrategyParam,
+                    OpenAI::StaticFileChunkingStrategyObjectParam
+                  )
+              }
+            )
+          end
+          def to_hash
+          end
+
+          module Attribute
+            extend OpenAI::Internal::Type::Union
+
+            Variants = T.type_alias { T.any(String, Float, T::Boolean) }
+
+            sig do
+              override.returns(
+                T::Array[
+                  OpenAI::VectorStores::FileBatchCreateParams::File::Attribute::Variants
+                ]
+              )
+            end
+            def self.variants
+            end
+          end
+        end
       end
     end
   end

data/rbi/openai/models/video.rbi

@@ -40,6 +40,10 @@ module OpenAI
       sig { returns(Integer) }
       attr_accessor :progress
 
+      # The prompt that was used to generate the video.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :prompt
+
       # Identifier of the source video if this video is a remix.
       sig { returns(T.nilable(String)) }
       attr_accessor :remixed_from_video_id
@@ -66,6 +70,7 @@ module OpenAI
           expires_at: T.nilable(Integer),
           model: OpenAI::VideoModel::OrSymbol,
           progress: Integer,
+          prompt: T.nilable(String),
           remixed_from_video_id: T.nilable(String),
           seconds: OpenAI::VideoSeconds::OrSymbol,
           size: OpenAI::VideoSize::OrSymbol,
@@ -88,6 +93,8 @@ module OpenAI
         model:,
         # Approximate completion percentage for the generation task.
         progress:,
+        # The prompt that was used to generate the video.
+        prompt:,
         # Identifier of the source video if this video is a remix.
         remixed_from_video_id:,
         # Duration of the generated clip in seconds.
@@ -112,6 +119,7 @@ module OpenAI
             model: OpenAI::VideoModel::TaggedSymbol,
             object: Symbol,
             progress: Integer,
+            prompt: T.nilable(String),
             remixed_from_video_id: T.nilable(String),
             seconds: OpenAI::VideoSeconds::TaggedSymbol,
             size: OpenAI::VideoSize::TaggedSymbol,

data/rbi/openai/resources/files.rbi

@@ -7,20 +7,19 @@ module OpenAI
       # up to 512 MB, and the size of all files uploaded by one organization can be up
       # to 1 TB.
       #
-      # The Assistants API supports files up to 2 million tokens and of specific file
-      # types. See the
-      # [Assistants Tools guide](https://platform.openai.com/docs/assistants/tools) for
-      # details.
-      #
-      # The Fine-tuning API only supports `.jsonl` files. The input also has certain
-      # required formats for fine-tuning
-      # [chat](https://platform.openai.com/docs/api-reference/fine-tuning/chat-input) or
-      # [completions](https://platform.openai.com/docs/api-reference/fine-tuning/completions-input)
-      # models.
-      #
-      # The Batch API only supports `.jsonl` files up to 200 MB in size. The input also
-      # has a specific required
-      # [format](https://platform.openai.com/docs/api-reference/batch/request-input).
+      # - The Assistants API supports files up to 2 million tokens and of specific file
+      #   types. See the
+      #   [Assistants Tools guide](https://platform.openai.com/docs/assistants/tools)
+      #   for details.
+      # - The Fine-tuning API only supports `.jsonl` files. The input also has certain
+      #   required formats for fine-tuning
+      #   [chat](https://platform.openai.com/docs/api-reference/fine-tuning/chat-input)
+      #   or
+      #   [completions](https://platform.openai.com/docs/api-reference/fine-tuning/completions-input)
+      #   models.
+      # - The Batch API only supports `.jsonl` files up to 200 MB in size. The input
+      #   also has a specific required
+      #   [format](https://platform.openai.com/docs/api-reference/batch/request-input).
       #
       # Please [contact us](https://help.openai.com/) if you need to increase these
       # storage limits.