openai 0.99.0 → 0.101.0

data/rbi/openai/models/beta/beta_responses_server_event.rbi

@@ -5009,6 +5009,11 @@ module OpenAI
               }
               attr_writer :error_type
 
+              # An opaque target for explicitly continuing this review, or null when
+              # unavailable.
+              sig { returns(T.nilable(String)) }
+              attr_accessor :review_target
+
               # An optional public continuation instruction.
               sig {
                 returns(
@@ -5035,6 +5040,8 @@ module OpenAI
                     OpenAI::Beta::BetaResponsesServerEvent::BetaResponseWsError::Error::Misalignment::ErrorType::OrSymbol
                   ),
 
+                  review_target: T.nilable(String),
+
                   steer: OpenAI::Beta::BetaResponsesServerEvent::BetaResponseWsError::Error::Misalignment::Steer::OrHash
                 )
                   .returns(T.attached_class)
@@ -5047,6 +5054,10 @@ module OpenAI
                 # An optional classification; clients must accept additional values.
                 error_type: nil,
 
+                # An opaque target for explicitly continuing this review, or null when
+                # unavailable.
+                review_target: nil,
+
                 # An optional public continuation instruction.
 
                 steer: nil
@@ -5060,6 +5071,7 @@ module OpenAI
                     error_type: T.nilable(
                       OpenAI::Beta::BetaResponsesServerEvent::BetaResponseWsError::Error::Misalignment::ErrorType::Variants
                     ),
+                    review_target: T.nilable(String),
                     steer: T.nilable(
                       OpenAI::Beta::BetaResponsesServerEvent::BetaResponseWsError::Error::Misalignment::Steer
                     )

data/rbi/openai/models/beta/beta_tool.rbi

@@ -976,9 +976,10 @@ module OpenAI
           sig { params(background: OpenAI::Beta::BetaTool::ImageGeneration::Background::OrSymbol).void }
           attr_writer :background
 
-          # Controls fidelity to the original input image(s). This parameter is supported
-          # for GPT image models that support input fidelity. `gpt-image-2` and
-          # `gpt-image-2-2026-04-21` ignore this parameter.
+          # Control how much effort the model will exert to match the style and features,
+          # especially facial features, of input images. Supports `high` and `low` on
+          # `gpt-image-1` and `gpt-image-1.5`; `gpt-image-1-mini` supports only `low`. For
+          # `gpt-image-2`, omit this parameter. Defaults to `low` on supported models.
           sig { returns(T.nilable(OpenAI::Beta::BetaTool::ImageGeneration::InputFidelity::OrSymbol)) }
           attr_accessor :input_fidelity
 
@@ -1103,9 +1104,10 @@ module OpenAI
             # set the output format to `png` or `webp`.
             background: nil,
 
-            # Controls fidelity to the original input image(s). This parameter is supported
-            # for GPT image models that support input fidelity. `gpt-image-2` and
-            # `gpt-image-2-2026-04-21` ignore this parameter.
+            # Control how much effort the model will exert to match the style and features,
+            # especially facial features, of input images. Supports `high` and `low` on
+            # `gpt-image-1` and `gpt-image-1.5`; `gpt-image-1-mini` supports only `low`. For
+            # `gpt-image-2`, omit this parameter. Defaults to `low` on supported models.
             input_fidelity: nil,
 
             # Optional mask for inpainting. Contains `image_url` (string, optional) and
@@ -1218,9 +1220,10 @@ module OpenAI
             end
           end
 
-          # Controls fidelity to the original input image(s). This parameter is supported
-          # for GPT image models that support input fidelity. `gpt-image-2` and
-          # `gpt-image-2-2026-04-21` ignore this parameter.
+          # Control how much effort the model will exert to match the style and features,
+          # especially facial features, of input images. Supports `high` and `low` on
+          # `gpt-image-1` and `gpt-image-1.5`; `gpt-image-1-mini` supports only `low`. For
+          # `gpt-image-2`, omit this parameter. Defaults to `low` on supported models.
           module InputFidelity
             extend OpenAI::Internal::Type::Enum
 

data/rbi/openai/models/beta/beta_tool_search_output_namespace_tool.rbi

@@ -0,0 +1,272 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    BetaToolSearchOutputNamespaceTool = Beta::BetaToolSearchOutputNamespaceTool
+
+    module Beta
+
+      class BetaToolSearchOutputNamespaceTool < OpenAI::Internal::Type::BaseModel
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Beta::BetaToolSearchOutputNamespaceTool,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        # A description of the namespace shown to the model.
+        sig { returns(String) }
+        attr_accessor :description
+
+        # The namespace name used in tool calls (for example, `crm`).
+        sig { returns(String) }
+        attr_accessor :name
+
+        # The function/custom tools loaded inside this namespace.
+        sig {
+          returns(
+            T::Array[
+              T.any(OpenAI::Beta::BetaToolSearchOutputNamespaceTool::Tool::Function, OpenAI::Beta::BetaCustomTool)
+            ]
+          )
+        }
+        attr_accessor :tools
+
+        # The type of the tool. Always `namespace`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # Groups function/custom tools under a shared namespace.
+        sig do
+          params(
+
+            description: String,
+
+            name: String,
+
+            tools: T::Array[
+              T.any(
+                OpenAI::Beta::BetaToolSearchOutputNamespaceTool::Tool::Function::OrHash,
+                OpenAI::Beta::BetaCustomTool::OrHash
+              )
+            ],
+
+            type: Symbol
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          # A description of the namespace shown to the model.
+          description:,
+
+          # The namespace name used in tool calls (for example, `crm`).
+          name:,
+
+          # The function/custom tools loaded inside this namespace.
+          tools:,
+
+          # The type of the tool. Always `namespace`.
+
+          type: :namespace
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              description: String,
+              name: String,
+              tools: T::Array[
+                T.any(OpenAI::Beta::BetaToolSearchOutputNamespaceTool::Tool::Function, OpenAI::Beta::BetaCustomTool)
+              ],
+              type: Symbol
+            }
+          )
+        end
+        def to_hash
+        end
+
+        # A function or custom tool loaded into a namespace by tool search.
+        module Tool
+          extend OpenAI::Internal::Type::Union
+
+          Variants = T.type_alias {
+            T.any(OpenAI::Beta::BetaToolSearchOutputNamespaceTool::Tool::Function, OpenAI::Beta::BetaCustomTool)
+          }
+
+          class Function < OpenAI::Internal::Type::BaseModel
+            OrHash = T.type_alias do
+              T.any(
+                OpenAI::Beta::BetaToolSearchOutputNamespaceTool::Tool::Function,
+                OpenAI::Internal::AnyHash
+              )
+            end
+
+            # The name of the loaded function tool.
+            sig { returns(String) }
+            attr_accessor :name
+
+            sig { returns(Symbol) }
+            attr_accessor :type
+
+            # The tool invocation context(s).
+            sig {
+              returns(
+                T.nilable(
+                  T::Array[OpenAI::Beta::BetaToolSearchOutputNamespaceTool::Tool::Function::AllowedCaller::OrSymbol]
+                )
+              )
+            }
+            attr_accessor :allowed_callers
+
+            # Whether the tool response can be returned asynchronously versus immediately
+            # returned on next response creation.
+            sig { returns(T.nilable(T::Boolean)) }
+            attr_reader :async
+
+            sig { params(async: T::Boolean).void }
+            attr_writer :async
+
+            # Whether this function should be deferred and discovered via tool search.
+            sig { returns(T.nilable(T::Boolean)) }
+            attr_reader :defer_loading
+
+            sig { params(defer_loading: T::Boolean).void }
+            attr_writer :defer_loading
+
+            sig { returns(T.nilable(String)) }
+            attr_accessor :description
+
+            # A JSON Schema describing the JSON value encoded in string outputs for this
+            # function tool. This does not describe content-array outputs.
+            sig { returns(T.nilable(T::Hash[Symbol, T.anything])) }
+            attr_accessor :output_schema
+
+            sig { returns(T.nilable(T.anything)) }
+            attr_accessor :parameters
+
+            # Whether to enforce strict parameter validation. If omitted, Responses attempts
+            # to use strict validation when the schema is compatible, and falls back to
+            # non-strict validation otherwise.
+            sig { returns(T.nilable(T::Boolean)) }
+            attr_accessor :strict
+
+            sig do
+              params(
+
+                name: String,
+
+                allowed_callers: T.nilable(
+                  T::Array[OpenAI::Beta::BetaToolSearchOutputNamespaceTool::Tool::Function::AllowedCaller::OrSymbol]
+                ),
+
+                async: T::Boolean,
+
+                defer_loading: T::Boolean,
+
+                description: T.nilable(String),
+
+                output_schema: T.nilable(T::Hash[Symbol, T.anything]),
+
+                parameters: T.nilable(T.anything),
+
+                strict: T.nilable(T::Boolean),
+
+                type: Symbol
+              )
+                .returns(T.attached_class)
+            end
+            def self.new(
+
+              # The name of the loaded function tool.
+              name:,
+
+              # The tool invocation context(s).
+              allowed_callers: nil,
+
+              # Whether the tool response can be returned asynchronously versus immediately
+              # returned on next response creation.
+              async: nil,
+
+              # Whether this function should be deferred and discovered via tool search.
+              defer_loading: nil,
+
+              description: nil,
+
+              # A JSON Schema describing the JSON value encoded in string outputs for this
+              # function tool. This does not describe content-array outputs.
+              output_schema: nil,
+
+              parameters: nil,
+
+              # Whether to enforce strict parameter validation. If omitted, Responses attempts
+              # to use strict validation when the schema is compatible, and falls back to
+              # non-strict validation otherwise.
+              strict: nil,
+
+              type: :function
+            )
+            end
+
+            sig do
+              override.returns(
+                {
+                  name: String,
+                  type: Symbol,
+                  allowed_callers: T.nilable(
+                    T::Array[OpenAI::Beta::BetaToolSearchOutputNamespaceTool::Tool::Function::AllowedCaller::OrSymbol]
+                  ),
+                  async: T::Boolean,
+                  defer_loading: T::Boolean,
+                  description: T.nilable(String),
+                  output_schema: T.nilable(T::Hash[Symbol, T.anything]),
+                  parameters: T.nilable(T.anything),
+                  strict: T.nilable(T::Boolean)
+                }
+              )
+            end
+            def to_hash
+            end
+
+            module AllowedCaller
+              extend OpenAI::Internal::Type::Enum
+
+              TaggedSymbol = T.type_alias {
+                T.all(Symbol, OpenAI::Beta::BetaToolSearchOutputNamespaceTool::Tool::Function::AllowedCaller)
+              }
+              OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+              DIRECT = T.let(
+                :direct,
+                OpenAI::Beta::BetaToolSearchOutputNamespaceTool::Tool::Function::AllowedCaller::TaggedSymbol
+              )
+              PROGRAMMATIC = T.let(
+                :programmatic,
+                OpenAI::Beta::BetaToolSearchOutputNamespaceTool::Tool::Function::AllowedCaller::TaggedSymbol
+              )
+
+              sig {
+                override.returns(
+                  T::Array[OpenAI::Beta::BetaToolSearchOutputNamespaceTool::Tool::Function::AllowedCaller::TaggedSymbol]
+                )
+              }
+              def self.values
+              end
+            end
+          end
+
+          sig { override.returns(T::Array[OpenAI::Beta::BetaToolSearchOutputNamespaceTool::Tool::Variants]) }
+          def self.variants
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/beta/environment_param.rbi

@@ -114,8 +114,8 @@ module OpenAI
           }
           attr_accessor :files
 
-          # Network access policy for the environment. Defaults to disabled for GA requests
-          # and enabled for beta requests.
+          # Network access policy for the environment. If omitted, the API version
+          # determines whether network access is enabled or disabled.
           sig { returns(T.nilable(OpenAI::Beta::EnvironmentParam::OpenAIHosted::Network)) }
           attr_reader :network
 
@@ -216,8 +216,8 @@ module OpenAI
             # Files available before the agent starts. Defaults to an empty list.
             files: nil,
 
-            # Network access policy for the environment. Defaults to disabled for GA requests
-            # and enabled for beta requests.
+            # Network access policy for the environment. If omitted, the API version
+            # determines whether network access is enabled or disabled.
             network: nil,
 
             # Packages to install in the environment. Defaults to empty package lists.
@@ -350,8 +350,8 @@ module OpenAI
             sig { returns(T.nilable(T::Array[String])) }
             attr_accessor :blocked_domains
 
-            # Network access policy for the environment. Defaults to disabled for GA requests
-            # and enabled for beta requests.
+            # Network access policy for the environment. If omitted, the API version
+            # determines whether network access is enabled or disabled.
             sig do
               params(
 

data/rbi/openai/models/beta/session_turn_error.rbi

@@ -67,6 +67,24 @@ module OpenAI
           # The organization has reached a usage, plan, or billing limit.
           USAGE_LIMIT_EXCEEDED = T.let(:usage_limit_exceeded, OpenAI::Beta::SessionTurnError::Code::TaggedSymbol)
 
+          # The project has reached its enforced spend limit.
+          PROJECT_SPEND_LIMIT_EXCEEDED = T.let(
+            :project_spend_limit_exceeded,
+            OpenAI::Beta::SessionTurnError::Code::TaggedSymbol
+          )
+
+          # The organization has reached its enforced spend limit.
+          ORGANIZATION_SPEND_LIMIT_EXCEEDED = T.let(
+            :organization_spend_limit_exceeded,
+            OpenAI::Beta::SessionTurnError::Code::TaggedSymbol
+          )
+
+          # The organization has reached its OpenAI-assigned usage limit.
+          ORGANIZATION_USAGE_LIMIT_EXCEEDED = T.let(
+            :organization_usage_limit_exceeded,
+            OpenAI::Beta::SessionTurnError::Code::TaggedSymbol
+          )
+
           # The organization has no API credits remaining.
           CREDIT_BALANCE_EXHAUSTED = T.let(
             :credit_balance_exhausted,

data/rbi/openai/models/chat/chat_completion_chunk.rbi

@@ -228,26 +228,29 @@ module OpenAI
             )
           end
 
-          # A chat completion delta generated by streamed model responses.
+          # A chat completion delta generated by streamed model responses. Streamed audio
+          # can arrive in partial updates with an ID, base64 data, or transcript text. The
+          # final audio update contains only its expiry timestamp.
           sig { returns(OpenAI::Chat::ChatCompletionChunk::Choice::Delta) }
           attr_reader :delta
 
           sig { params(delta: OpenAI::Chat::ChatCompletionChunk::Choice::Delta::OrHash).void }
           attr_writer :delta
 
+          # The index of the choice in the list of choices.
+          sig { returns(Integer) }
+          attr_accessor :index
+
           # The reason the model stopped generating tokens. This will be `stop` if the model
           # hit a natural stop point or a provided stop sequence, `length` if the maximum
           # number of tokens specified in the request was reached, `content_filter` if
           # content was omitted due to a flag from our content filters, `tool_calls` if the
           # model called a tool, or `function_call` (deprecated) if the model called a
-          # function.
+          # function. Omitted from the final audio update containing only
+          # `delta.audio.expires_at`.
           sig { returns(T.nilable(OpenAI::Chat::ChatCompletionChunk::Choice::FinishReason::TaggedSymbol)) }
           attr_accessor :finish_reason
 
-          # The index of the choice in the list of choices.
-          sig { returns(Integer) }
-          attr_accessor :index
-
           # Log probability information for the choice.
           sig { returns(T.nilable(OpenAI::Chat::ChatCompletionChunk::Choice::Logprobs)) }
           attr_reader :logprobs
@@ -260,29 +263,32 @@ module OpenAI
 
               delta: OpenAI::Chat::ChatCompletionChunk::Choice::Delta::OrHash,
 
-              finish_reason: T.nilable(OpenAI::Chat::ChatCompletionChunk::Choice::FinishReason::OrSymbol),
-
               index: Integer,
 
+              finish_reason: T.nilable(OpenAI::Chat::ChatCompletionChunk::Choice::FinishReason::OrSymbol),
+
               logprobs: T.nilable(OpenAI::Chat::ChatCompletionChunk::Choice::Logprobs::OrHash)
             )
               .returns(T.attached_class)
           end
           def self.new(
 
-            # A chat completion delta generated by streamed model responses.
+            # A chat completion delta generated by streamed model responses. Streamed audio
+            # can arrive in partial updates with an ID, base64 data, or transcript text. The
+            # final audio update contains only its expiry timestamp.
             delta:,
 
+            # The index of the choice in the list of choices.
+            index:,
+
             # The reason the model stopped generating tokens. This will be `stop` if the model
             # hit a natural stop point or a provided stop sequence, `length` if the maximum
             # number of tokens specified in the request was reached, `content_filter` if
             # content was omitted due to a flag from our content filters, `tool_calls` if the
             # model called a tool, or `function_call` (deprecated) if the model called a
-            # function.
-            finish_reason:,
-
-            # The index of the choice in the list of choices.
-            index:,
+            # function. Omitted from the final audio update containing only
+            # `delta.audio.expires_at`.
+            finish_reason: nil,
 
             # Log probability information for the choice.
 
@@ -294,8 +300,8 @@ module OpenAI
             override.returns(
               {
                 delta: OpenAI::Chat::ChatCompletionChunk::Choice::Delta,
-                finish_reason: T.nilable(OpenAI::Chat::ChatCompletionChunk::Choice::FinishReason::TaggedSymbol),
                 index: Integer,
+                finish_reason: T.nilable(OpenAI::Chat::ChatCompletionChunk::Choice::FinishReason::TaggedSymbol),
                 logprobs: T.nilable(OpenAI::Chat::ChatCompletionChunk::Choice::Logprobs)
               }
             )
@@ -311,6 +317,14 @@ module OpenAI
               )
             end
 
+            # A partial audio response. Audio chunks may carry an ID, base64 data, or
+            # transcript text; the final audio update contains only its expiry timestamp.
+            sig { returns(T.nilable(OpenAI::Chat::ChatCompletionChunk::Choice::Delta::Audio)) }
+            attr_reader :audio
+
+            sig { params(audio: OpenAI::Chat::ChatCompletionChunk::Choice::Delta::Audio::OrHash).void }
+            attr_writer :audio
+
             # The contents of the chunk message.
             sig { returns(T.nilable(String)) }
             attr_accessor :content
@@ -342,10 +356,14 @@ module OpenAI
             }
             attr_writer :tool_calls
 
-            # A chat completion delta generated by streamed model responses.
+            # A chat completion delta generated by streamed model responses. Streamed audio
+            # can arrive in partial updates with an ID, base64 data, or transcript text. The
+            # final audio update contains only its expiry timestamp.
             sig do
               params(
 
+                audio: OpenAI::Chat::ChatCompletionChunk::Choice::Delta::Audio::OrHash,
+
                 content: T.nilable(String),
 
                 function_call: OpenAI::Chat::ChatCompletionChunk::Choice::Delta::FunctionCall::OrHash,
@@ -360,6 +378,10 @@ module OpenAI
             end
             def self.new(
 
+              # A partial audio response. Audio chunks may carry an ID, base64 data, or
+              # transcript text; the final audio update contains only its expiry timestamp.
+              audio: nil,
+
               # The contents of the chunk message.
               content: nil,
 
@@ -380,6 +402,7 @@ module OpenAI
             sig do
               override.returns(
                 {
+                  audio: OpenAI::Chat::ChatCompletionChunk::Choice::Delta::Audio,
                   content: T.nilable(String),
                   function_call: OpenAI::Chat::ChatCompletionChunk::Choice::Delta::FunctionCall,
                   refusal: T.nilable(String),
@@ -391,6 +414,88 @@ module OpenAI
             def to_hash
             end
 
+            class Audio < OpenAI::Internal::Type::BaseModel
+              OrHash = T.type_alias do
+                T.any(
+                  OpenAI::Chat::ChatCompletionChunk::Choice::Delta::Audio,
+                  OpenAI::Internal::AnyHash
+                )
+              end
+
+              # Unique identifier for this audio response.
+              sig { returns(T.nilable(String)) }
+              attr_reader :id
+
+              sig { params(id: String).void }
+              attr_writer :id
+
+              # Base64 encoded audio bytes generated by the model, in the format specified in
+              # the request.
+              sig { returns(T.nilable(String)) }
+              attr_reader :data
+
+              sig { params(data: String).void }
+              attr_writer :data
+
+              # The Unix timestamp (in seconds) for when this audio response will no longer be
+              # accessible on the server for use in multi-turn conversations.
+              sig { returns(T.nilable(Integer)) }
+              attr_reader :expires_at
+
+              sig { params(expires_at: Integer).void }
+              attr_writer :expires_at
+
+              # Transcript text from this audio chunk.
+              sig { returns(T.nilable(String)) }
+              attr_reader :transcript
+
+              sig { params(transcript: String).void }
+              attr_writer :transcript
+
+              # A partial audio response. Audio chunks may carry an ID, base64 data, or
+              # transcript text; the final audio update contains only its expiry timestamp.
+              sig do
+                params(
+
+                  id: String,
+
+                  data: String,
+
+                  expires_at: Integer,
+
+                  transcript: String
+                )
+                  .returns(T.attached_class)
+              end
+              def self.new(
+
+                # Unique identifier for this audio response.
+                id: nil,
+
+                # Base64 encoded audio bytes generated by the model, in the format specified in
+                # the request.
+                data: nil,
+
+                # The Unix timestamp (in seconds) for when this audio response will no longer be
+                # accessible on the server for use in multi-turn conversations.
+                expires_at: nil,
+
+                # Transcript text from this audio chunk.
+
+                transcript: nil
+              )
+              end
+
+              sig do
+                override.returns(
+                  {id: String, data: String, expires_at: Integer, transcript: String}
+                )
+              end
+              def to_hash
+              end
+
+            end
+
             class FunctionCall < OpenAI::Internal::Type::BaseModel
               OrHash = T.type_alias do
                 T.any(
@@ -633,7 +738,8 @@ module OpenAI
           # number of tokens specified in the request was reached, `content_filter` if
           # content was omitted due to a flag from our content filters, `tool_calls` if the
           # model called a tool, or `function_call` (deprecated) if the model called a
-          # function.
+          # function. Omitted from the final audio update containing only
+          # `delta.audio.expires_at`.
           module FinishReason
             extend OpenAI::Internal::Type::Enum