openai 0.89.0 → 0.91.0

data/rbi/openai/models/beta/summary_text.rbi

@@ -0,0 +1,59 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Beta
+
+      class SummaryText < OpenAI::Internal::Type::BaseModel
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Beta::SummaryText,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        # The reasoning summary text.
+        sig { returns(String) }
+        attr_accessor :text
+
+        # The content type. Always `summary_text`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # A reasoning summary content part.
+        sig do
+          params(
+
+            text: String,
+
+            type: Symbol
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          # The reasoning summary text.
+          text:,
+
+          # The content type. Always `summary_text`.
+
+          type: :summary_text
+        )
+        end
+
+        sig do
+          override.returns(
+            {text: String, type: Symbol}
+          )
+        end
+        def to_hash
+        end
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/beta/text_format.rbi

@@ -0,0 +1,113 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Beta
+
+      # The effective output format for generated text.
+      module TextFormat
+        extend OpenAI::Internal::Type::Union
+
+        Variants = T.type_alias do
+          T.any(
+            OpenAI::Beta::TextFormat::Text,
+            OpenAI::Beta::TextFormat::JSONSchema
+          )
+        end
+
+        class Text < OpenAI::Internal::Type::BaseModel
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::Beta::TextFormat::Text,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+          # The type of the object. Always `text`.
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          # Generates ordinary text without a structured-output constraint.
+          sig do
+            params(
+
+              type: Symbol
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(
+
+            # The type of the object. Always `text`.
+
+            type: :text
+          )
+          end
+
+          sig do
+            override.returns(
+              {type: Symbol}
+            )
+          end
+          def to_hash
+          end
+
+        end
+
+        class JSONSchema < OpenAI::Internal::Type::BaseModel
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::Beta::TextFormat::JSONSchema,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+          # The JSON Schema that generated text must match.
+          sig { returns(T::Hash[Symbol, T.anything]) }
+          attr_accessor :schema
+
+          # The type of the object. Always `json_schema`.
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          # Constrains generated text to a JSON Schema.
+          sig do
+            params(
+
+              schema: T::Hash[Symbol, T.anything],
+
+              type: Symbol
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(
+
+            # The JSON Schema that generated text must match.
+            schema:,
+
+            # The type of the object. Always `json_schema`.
+
+            type: :json_schema
+          )
+          end
+
+          sig do
+            override.returns(
+              {schema: T::Hash[Symbol, T.anything], type: Symbol}
+            )
+          end
+          def to_hash
+          end
+
+        end
+
+        sig { override.returns(T::Array[OpenAI::Beta::TextFormat::Variants]) }
+        def self.variants
+        end
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/beta/text_format_param.rbi

@@ -0,0 +1,113 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Beta
+
+      # The output format for generated text.
+      module TextFormatParam
+        extend OpenAI::Internal::Type::Union
+
+        Variants = T.type_alias do
+          T.any(
+            OpenAI::Beta::TextFormatParam::Text,
+            OpenAI::Beta::TextFormatParam::JSONSchema
+          )
+        end
+
+        class Text < OpenAI::Internal::Type::BaseModel
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::Beta::TextFormatParam::Text,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+          # The type of the object. Always `text`.
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          # Generates ordinary text without a structured-output constraint.
+          sig do
+            params(
+
+              type: Symbol
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(
+
+            # The type of the object. Always `text`.
+
+            type: :text
+          )
+          end
+
+          sig do
+            override.returns(
+              {type: Symbol}
+            )
+          end
+          def to_hash
+          end
+
+        end
+
+        class JSONSchema < OpenAI::Internal::Type::BaseModel
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::Beta::TextFormatParam::JSONSchema,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+          # The JSON Schema that generated text must match.
+          sig { returns(T::Hash[Symbol, T.anything]) }
+          attr_accessor :schema
+
+          # The type of the object. Always `json_schema`.
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          # Constrains generated text to a JSON Schema.
+          sig do
+            params(
+
+              schema: T::Hash[Symbol, T.anything],
+
+              type: Symbol
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(
+
+            # The JSON Schema that generated text must match.
+            schema:,
+
+            # The type of the object. Always `json_schema`.
+
+            type: :json_schema
+          )
+          end
+
+          sig do
+            override.returns(
+              {schema: T::Hash[Symbol, T.anything], type: Symbol}
+            )
+          end
+          def to_hash
+          end
+
+        end
+
+        sig { override.returns(T::Array[OpenAI::Beta::TextFormatParam::Variants]) }
+        def self.variants
+        end
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/beta/token_usage.rbi

@@ -0,0 +1,174 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Beta
+
+      class TokenUsage < OpenAI::Internal::Type::BaseModel
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Beta::TokenUsage,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        # The number of input tokens used by the agent.
+        sig { returns(Integer) }
+        attr_accessor :input_tokens
+
+        # A breakdown of the agent's input token usage.
+        sig { returns(OpenAI::Beta::TokenUsage::InputTokensDetails) }
+        attr_reader :input_tokens_details
+
+        sig { params(input_tokens_details: OpenAI::Beta::TokenUsage::InputTokensDetails::OrHash).void }
+        attr_writer :input_tokens_details
+
+        # The number of output tokens generated by the agent.
+        sig { returns(Integer) }
+        attr_accessor :output_tokens
+
+        # A breakdown of the agent's output token usage.
+        sig { returns(OpenAI::Beta::TokenUsage::OutputTokensDetails) }
+        attr_reader :output_tokens_details
+
+        sig { params(output_tokens_details: OpenAI::Beta::TokenUsage::OutputTokensDetails::OrHash).void }
+        attr_writer :output_tokens_details
+
+        # The total number of input and output tokens used by the agent.
+        sig { returns(Integer) }
+        attr_accessor :total_tokens
+
+        # Recorded token usage for a session or turn. Usage is best effort and may change.
+        sig do
+          params(
+
+            input_tokens: Integer,
+
+            input_tokens_details: OpenAI::Beta::TokenUsage::InputTokensDetails::OrHash,
+
+            output_tokens: Integer,
+
+            output_tokens_details: OpenAI::Beta::TokenUsage::OutputTokensDetails::OrHash,
+
+            total_tokens: Integer
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          # The number of input tokens used by the agent.
+          input_tokens:,
+
+          # A breakdown of the agent's input token usage.
+          input_tokens_details:,
+
+          # The number of output tokens generated by the agent.
+          output_tokens:,
+
+          # A breakdown of the agent's output token usage.
+          output_tokens_details:,
+
+          # The total number of input and output tokens used by the agent.
+
+          total_tokens:
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              input_tokens: Integer,
+              input_tokens_details: OpenAI::Beta::TokenUsage::InputTokensDetails,
+              output_tokens: Integer,
+              output_tokens_details: OpenAI::Beta::TokenUsage::OutputTokensDetails,
+              total_tokens: Integer
+            }
+          )
+        end
+        def to_hash
+        end
+
+        class InputTokensDetails < OpenAI::Internal::Type::BaseModel
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::Beta::TokenUsage::InputTokensDetails,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+          # The number of input tokens retrieved from the prompt cache.
+          sig { returns(Integer) }
+          attr_accessor :cached_tokens
+
+          # A breakdown of the agent's input token usage.
+          sig do
+            params(
+
+              cached_tokens: Integer
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(
+
+            # The number of input tokens retrieved from the prompt cache.
+
+            cached_tokens:
+          )
+          end
+
+          sig do
+            override.returns(
+              {cached_tokens: Integer}
+            )
+          end
+          def to_hash
+          end
+
+        end
+
+        class OutputTokensDetails < OpenAI::Internal::Type::BaseModel
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::Beta::TokenUsage::OutputTokensDetails,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+          # The number of output tokens used for reasoning.
+          sig { returns(Integer) }
+          attr_accessor :reasoning_tokens
+
+          # A breakdown of the agent's output token usage.
+          sig do
+            params(
+
+              reasoning_tokens: Integer
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(
+
+            # The number of output tokens used for reasoning.
+
+            reasoning_tokens:
+          )
+          end
+
+          sig do
+            override.returns(
+              {reasoning_tokens: Integer}
+            )
+          end
+          def to_hash
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/beta/web_search_action.rbi

@@ -0,0 +1,227 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Beta
+
+      # An action performed by the web search tool.
+      module WebSearchAction
+        extend OpenAI::Internal::Type::Union
+
+        Variants = T.type_alias do
+          T.any(
+            OpenAI::Beta::WebSearchAction::Search,
+            OpenAI::Beta::WebSearchAction::OpenPage,
+            OpenAI::Beta::WebSearchAction::FindInPage,
+            OpenAI::Beta::WebSearchAction::Other
+          )
+        end
+
+        class Search < OpenAI::Internal::Type::BaseModel
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::Beta::WebSearchAction::Search,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+          # The search queries, when multiple queries were used.
+          sig { returns(T.nilable(T::Array[String])) }
+          attr_accessor :queries
+
+          # The search query, when a single query was used.
+          sig { returns(T.nilable(String)) }
+          attr_accessor :query
+
+          # The type of the object. Always `search`.
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          # A search query or group of search queries.
+          sig do
+            params(
+
+              queries: T.nilable(T::Array[String]),
+
+              query: T.nilable(String),
+
+              type: Symbol
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(
+
+            # The search queries, when multiple queries were used.
+            queries:,
+
+            # The search query, when a single query was used.
+            query:,
+
+            # The type of the object. Always `search`.
+
+            type: :search
+          )
+          end
+
+          sig do
+            override.returns(
+              {queries: T.nilable(T::Array[String]), query: T.nilable(String), type: Symbol}
+            )
+          end
+          def to_hash
+          end
+
+        end
+
+        class OpenPage < OpenAI::Internal::Type::BaseModel
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::Beta::WebSearchAction::OpenPage,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+          # The type of the object. Always `open_page`.
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          # The URL of the page that was opened.
+          sig { returns(T.nilable(String)) }
+          attr_accessor :url
+
+          # Opens a web page.
+          sig do
+            params(
+
+              url: T.nilable(String),
+
+              type: Symbol
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(
+
+            # The URL of the page that was opened.
+            url:,
+
+            # The type of the object. Always `open_page`.
+
+            type: :open_page
+          )
+          end
+
+          sig do
+            override.returns(
+              {type: Symbol, url: T.nilable(String)}
+            )
+          end
+          def to_hash
+          end
+
+        end
+
+        class FindInPage < OpenAI::Internal::Type::BaseModel
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::Beta::WebSearchAction::FindInPage,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+          # The text pattern that was searched for.
+          sig { returns(T.nilable(String)) }
+          attr_accessor :pattern
+
+          # The type of the object. Always `find_in_page`.
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          # The URL of the page that was searched.
+          sig { returns(T.nilable(String)) }
+          attr_accessor :url
+
+          # Finds text within a web page.
+          sig do
+            params(
+
+              pattern: T.nilable(String),
+
+              url: T.nilable(String),
+
+              type: Symbol
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(
+
+            # The text pattern that was searched for.
+            pattern:,
+
+            # The URL of the page that was searched.
+            url:,
+
+            # The type of the object. Always `find_in_page`.
+
+            type: :find_in_page
+          )
+          end
+
+          sig do
+            override.returns(
+              {pattern: T.nilable(String), type: Symbol, url: T.nilable(String)}
+            )
+          end
+          def to_hash
+          end
+
+        end
+
+        class Other < OpenAI::Internal::Type::BaseModel
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::Beta::WebSearchAction::Other,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+          # The type of the object. Always `other`.
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          # Another web search action.
+          sig do
+            params(
+
+              type: Symbol
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(
+
+            # The type of the object. Always `other`.
+
+            type: :other
+          )
+          end
+
+          sig do
+            override.returns(
+              {type: Symbol}
+            )
+          end
+          def to_hash
+          end
+
+        end
+
+        sig { override.returns(T::Array[OpenAI::Beta::WebSearchAction::Variants]) }
+        def self.variants
+        end
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/chat_model.rbi

@@ -29,7 +29,6 @@ module OpenAI
       GPT_5_1 = T.let(:"gpt-5.1", OpenAI::ChatModel::TaggedSymbol)
       GPT_5_1_2025_11_13 = T.let(:"gpt-5.1-2025-11-13", OpenAI::ChatModel::TaggedSymbol)
       GPT_5_1_CODEX = T.let(:"gpt-5.1-codex", OpenAI::ChatModel::TaggedSymbol)
-      GPT_5_1_MINI = T.let(:"gpt-5.1-mini", OpenAI::ChatModel::TaggedSymbol)
       GPT_5_1_CHAT_LATEST = T.let(:"gpt-5.1-chat-latest", OpenAI::ChatModel::TaggedSymbol)
       GPT_5 = T.let(:"gpt-5", OpenAI::ChatModel::TaggedSymbol)
       GPT_5_MINI = T.let(:"gpt-5-mini", OpenAI::ChatModel::TaggedSymbol)
@@ -60,6 +59,8 @@ module OpenAI
       GPT_4O_2024_11_20 = T.let(:"gpt-4o-2024-11-20", OpenAI::ChatModel::TaggedSymbol)
       GPT_4O_2024_08_06 = T.let(:"gpt-4o-2024-08-06", OpenAI::ChatModel::TaggedSymbol)
       GPT_4O_2024_05_13 = T.let(:"gpt-4o-2024-05-13", OpenAI::ChatModel::TaggedSymbol)
+      GPT_AUDIO_MINI = T.let(:"gpt-audio-mini", OpenAI::ChatModel::TaggedSymbol)
+      GPT_AUDIO_MINI_2025_12_15 = T.let(:"gpt-audio-mini-2025-12-15", OpenAI::ChatModel::TaggedSymbol)
       GPT_4O_AUDIO_PREVIEW = T.let(:"gpt-4o-audio-preview", OpenAI::ChatModel::TaggedSymbol)
       GPT_4O_AUDIO_PREVIEW_2024_10_01 = T.let(:"gpt-4o-audio-preview-2024-10-01", OpenAI::ChatModel::TaggedSymbol)
       GPT_4O_AUDIO_PREVIEW_2024_12_17 = T.let(:"gpt-4o-audio-preview-2024-12-17", OpenAI::ChatModel::TaggedSymbol)
@@ -99,6 +100,7 @@ module OpenAI
       GPT_3_5_TURBO_1106 = T.let(:"gpt-3.5-turbo-1106", OpenAI::ChatModel::TaggedSymbol)
       GPT_3_5_TURBO_0125 = T.let(:"gpt-3.5-turbo-0125", OpenAI::ChatModel::TaggedSymbol)
       GPT_3_5_TURBO_16K_0613 = T.let(:"gpt-3.5-turbo-16k-0613", OpenAI::ChatModel::TaggedSymbol)
+      GPT_5_1_MINI = T.let(:"gpt-5.1-mini", OpenAI::ChatModel::TaggedSymbol)
 
       sig { override.returns(T::Array[OpenAI::ChatModel::TaggedSymbol]) }
       def self.values