openai 0.99.0 → 0.101.0

data/sig/openai/models/decision.rbs

@@ -0,0 +1,296 @@
+module OpenAI
+  module Models
+    type decision =
+      {
+        answers: ::Array[OpenAI::Models::Decision::answer],
+        model: String,
+        usage: OpenAI::Decision::Usage
+      }
+
+    class Decision < OpenAI::Internal::Type::BaseModel
+      attr_accessor answers: ::Array[OpenAI::Models::Decision::answer]
+
+      attr_accessor model: String
+
+      attr_accessor usage: OpenAI::Decision::Usage
+
+      def initialize: (
+        answers: ::Array[OpenAI::Models::Decision::answer],
+        model: String,
+        usage: OpenAI::Decision::Usage
+      ) -> void
+
+      def to_hash: -> {
+        answers: ::Array[OpenAI::Models::Decision::answer],
+        model: String,
+        usage: OpenAI::Decision::Usage
+      }
+
+      type answer =
+        OpenAI::Decision::Answer::Predicate
+        | OpenAI::Decision::Answer::Choice
+        | OpenAI::Decision::Answer::Score
+        | OpenAI::Decision::Answer::Refusal
+
+      module Answer
+        extend OpenAI::Internal::Type::Union
+
+        type predicate =
+          { name: String?, probability: Float, ?type: :predicate }
+
+        class Predicate < OpenAI::Internal::Type::BaseModel
+          attr_accessor name: String?
+
+          attr_accessor probability: Float
+
+          # The type of the object. Always `predicate`.
+          attr_accessor type: :predicate
+
+          # @param type
+          #   The type of the object. Always `predicate`.
+          def initialize: (
+            name: String?,
+            probability: Float,
+            ?type: :predicate
+          ) -> void
+
+          def to_hash: -> {
+            name: String?,
+            probability: Float,
+            ?type: :predicate
+          }
+        end
+
+        type choice =
+          {
+            choice: OpenAI::Models::Decision::Answer::Choice::choice,
+            confidence: Float,
+            name: String?,
+            probabilities: ::Array[OpenAI::Decision::Answer::Choice::Probability],
+            ?type: :choice
+          }
+
+        class Choice < OpenAI::Internal::Type::BaseModel
+          # Choice values are typed: a string and a boolean with the same text are distinct.
+          attr_accessor choice: OpenAI::Models::Decision::Answer::Choice::choice
+
+          attr_accessor confidence: Float
+
+          attr_accessor name: String?
+
+          attr_accessor probabilities: ::Array[OpenAI::Decision::Answer::Choice::Probability]
+
+          # The type of the object. Always `choice`.
+          attr_accessor type: :choice
+
+          # @param choice
+          #   Choice values are typed: a string and a boolean with the same text are distinct.
+          # @param type
+          #   The type of the object. Always `choice`.
+          def initialize: (
+            choice: OpenAI::Models::Decision::Answer::Choice::choice,
+            confidence: Float,
+            name: String?,
+            probabilities: ::Array[OpenAI::Decision::Answer::Choice::Probability],
+            ?type: :choice
+          ) -> void
+
+          def to_hash: -> {
+            choice: OpenAI::Models::Decision::Answer::Choice::choice,
+            confidence: Float,
+            name: String?,
+            probabilities: ::Array[OpenAI::Decision::Answer::Choice::Probability],
+            ?type: :choice
+          }
+
+          type choice = String | bool
+
+          module Choice
+            extend OpenAI::Internal::Type::Union
+
+            def self?.variants: -> ::Array[OpenAI::Models::Decision::Answer::Choice::choice]
+          end
+
+          type probability =
+            {
+              probability: Float,
+              value: OpenAI::Models::Decision::Answer::Choice::Probability::value
+            }
+
+          class Probability < OpenAI::Internal::Type::BaseModel
+            attr_accessor probability: Float
+
+            # Choice values are typed: a string and a boolean with the same text are distinct.
+            attr_accessor value: OpenAI::Models::Decision::Answer::Choice::Probability::value
+
+            # @param value
+            #   Choice values are typed: a string and a boolean with the same text are distinct.
+            def initialize: (
+              probability: Float,
+              value: OpenAI::Models::Decision::Answer::Choice::Probability::value
+            ) -> void
+
+            def to_hash: -> {
+              probability: Float,
+              value: OpenAI::Models::Decision::Answer::Choice::Probability::value
+            }
+
+            type value = String | bool
+
+            module Value
+              extend OpenAI::Internal::Type::Union
+
+              def self?.variants: -> ::Array[OpenAI::Models::Decision::Answer::Choice::Probability::value]
+            end
+          end
+        end
+
+        type score =
+          {
+            confidence: Float,
+            name: String?,
+            probabilities: ::Array[OpenAI::Decision::Answer::Score::Probability],
+            score: Float,
+            ?type: :score
+          }
+
+        class Score < OpenAI::Internal::Type::BaseModel
+          attr_accessor confidence: Float
+
+          attr_accessor name: String?
+
+          attr_accessor probabilities: ::Array[OpenAI::Decision::Answer::Score::Probability]
+
+          attr_accessor score: Float
+
+          # The type of the object. Always `score`.
+          attr_accessor type: :score
+
+          # @param type
+          #   The type of the object. Always `score`.
+          def initialize: (
+            confidence: Float,
+            name: String?,
+            probabilities: ::Array[OpenAI::Decision::Answer::Score::Probability],
+            score: Float,
+            ?type: :score
+          ) -> void
+
+          def to_hash: -> {
+            confidence: Float,
+            name: String?,
+            probabilities: ::Array[OpenAI::Decision::Answer::Score::Probability],
+            score: Float,
+            ?type: :score
+          }
+
+          type probability =
+            { label: String, probability: Float, value: Integer }
+
+          class Probability < OpenAI::Internal::Type::BaseModel
+            attr_accessor label: String
+
+            attr_accessor probability: Float
+
+            attr_accessor value: Integer
+
+            def initialize: (
+              label: String,
+              probability: Float,
+              value: Integer
+            ) -> void
+
+            def to_hash: -> {
+              label: String,
+              probability: Float,
+              value: Integer
+            }
+          end
+        end
+
+        type refusal = { name: String?, ?type: :refusal }
+
+        class Refusal < OpenAI::Internal::Type::BaseModel
+          attr_accessor name: String?
+
+          # The type of the object. Always `refusal`.
+          attr_accessor type: :refusal
+
+          # @param type
+          #   The type of the object. Always `refusal`.
+          def initialize: (name: String?, ?type: :refusal) -> void
+
+          def to_hash: -> { name: String?, ?type: :refusal }
+        end
+
+        def self?.variants: -> ::Array[OpenAI::Models::Decision::answer]
+      end
+
+      type usage =
+        {
+          input_tokens: Integer,
+          input_tokens_details: OpenAI::Decision::Usage::InputTokensDetails,
+          output_tokens: Integer,
+          output_tokens_details: OpenAI::Decision::Usage::OutputTokensDetails,
+          total_tokens: Integer
+        }
+
+      class Usage < OpenAI::Internal::Type::BaseModel
+        attr_accessor input_tokens: Integer
+
+        attr_accessor input_tokens_details: OpenAI::Decision::Usage::InputTokensDetails
+
+        attr_accessor output_tokens: Integer
+
+        attr_accessor output_tokens_details: OpenAI::Decision::Usage::OutputTokensDetails
+
+        attr_accessor total_tokens: Integer
+
+        def initialize: (
+          input_tokens: Integer,
+          input_tokens_details: OpenAI::Decision::Usage::InputTokensDetails,
+          output_tokens: Integer,
+          output_tokens_details: OpenAI::Decision::Usage::OutputTokensDetails,
+          total_tokens: Integer
+        ) -> void
+
+        def to_hash: -> {
+          input_tokens: Integer,
+          input_tokens_details: OpenAI::Decision::Usage::InputTokensDetails,
+          output_tokens: Integer,
+          output_tokens_details: OpenAI::Decision::Usage::OutputTokensDetails,
+          total_tokens: Integer
+        }
+
+        type input_tokens_details =
+          { cache_write_tokens: Integer, cached_tokens: Integer }
+
+        class InputTokensDetails < OpenAI::Internal::Type::BaseModel
+          attr_accessor cache_write_tokens: Integer
+
+          attr_accessor cached_tokens: Integer
+
+          def initialize: (
+            cache_write_tokens: Integer,
+            cached_tokens: Integer
+          ) -> void
+
+          def to_hash: -> {
+            cache_write_tokens: Integer,
+            cached_tokens: Integer
+          }
+        end
+
+        type output_tokens_details = { reasoning_tokens: Integer }
+
+        class OutputTokensDetails < OpenAI::Internal::Type::BaseModel
+          attr_accessor reasoning_tokens: Integer
+
+          def initialize: (reasoning_tokens: Integer) -> void
+
+          def to_hash: -> { reasoning_tokens: Integer }
+        end
+      end
+    end
+  end
+end

data/sig/openai/models/decision_create_params.rbs

@@ -0,0 +1,227 @@
+module OpenAI
+  module Models
+    type decision_create_params =
+      {
+        input: OpenAI::Models::DecisionCreateParams::input,
+        model: String,
+        questions: ::Array[OpenAI::Models::DecisionCreateParams::question],
+        ?safety_identifier: String?,
+        ?request_options: OpenAI::request_opts
+      }
+
+    class DecisionCreateParams < OpenAI::Internal::Type::BaseModel
+      extend OpenAI::Internal::Type::RequestParameters::Converter
+      include OpenAI::Internal::Type::RequestParameters
+
+      # Shared evidence, as a string or an array of user messages containing text and
+      # inline images. Non-user roles, function calls, function-call outputs, files,
+      # audio, and item references are not supported. At most 128 image parts are
+      # allowed across all messages in one request.
+      attr_accessor input: OpenAI::Models::DecisionCreateParams::input
+
+      attr_accessor model: String
+
+      attr_accessor questions: ::Array[OpenAI::Models::DecisionCreateParams::question]
+
+      # Opaque caller-provided end-user identifier, scoped by the verified org. Match
+      # Responses' limit; this is never the authenticated user identity.
+      attr_accessor safety_identifier: String?
+
+      # @param input
+      #   Shared evidence, as a string or an array of user messages containing text and
+      #   inline images. Non-user roles, function calls, function-call outputs, files,
+      #   audio, and item references are not supported. At most 128 image parts are
+      #   allowed across all messages in one request.
+      # @param safety_identifier
+      #   Opaque caller-provided end-user identifier, scoped by the verified org. Match
+      #   Responses' limit; this is never the authenticated user identity.
+      def initialize: (
+        input: OpenAI::Models::DecisionCreateParams::input,
+        model: String,
+        questions: ::Array[OpenAI::Models::DecisionCreateParams::question],
+        ?safety_identifier: String?,
+        ?request_options: OpenAI::request_opts
+      ) -> void
+
+      def to_hash: -> {
+        input: OpenAI::Models::DecisionCreateParams::input,
+        model: String,
+        questions: ::Array[OpenAI::Models::DecisionCreateParams::question],
+        ?safety_identifier: String?,
+        ?request_options: OpenAI::RequestOptions
+      }
+
+      type input = String | ::Array[OpenAI::DecisionInputMessage]
+
+      module Input
+        extend OpenAI::Internal::Type::Union
+
+        def self?.variants: -> ::Array[OpenAI::Models::DecisionCreateParams::input]
+
+        DecisionInputMessageArray: OpenAI::Internal::Type::Converter
+      end
+
+      type question =
+        OpenAI::DecisionCreateParams::Question::Predicate
+        | OpenAI::DecisionCreateParams::Question::Choice
+        | OpenAI::DecisionCreateParams::Question::Score
+
+      module Question
+        extend OpenAI::Internal::Type::Union
+
+        type predicate =
+          { instructions: String, ?type: :predicate, ?name: String }
+
+        class Predicate < OpenAI::Internal::Type::BaseModel
+          attr_accessor instructions: String
+
+          # The type of the object. Always `predicate`.
+          attr_accessor type: :predicate
+
+          attr_reader name: String?
+
+          def name=: (String) -> String
+
+          # @param type
+          #   The type of the object. Always `predicate`.
+          def initialize: (
+            instructions: String,
+            ?name: String,
+            ?type: :predicate
+          ) -> void
+
+          def to_hash: -> {
+            instructions: String,
+            ?type: :predicate,
+            ?name: String
+          }
+        end
+
+        type choice =
+          {
+            choices: ::Array[OpenAI::DecisionCreateParams::Question::Choice::Choice],
+            instructions: String,
+            ?type: :choice,
+            ?name: String
+          }
+
+        class Choice < OpenAI::Internal::Type::BaseModel
+          attr_accessor choices: ::Array[OpenAI::DecisionCreateParams::Question::Choice::Choice]
+
+          attr_accessor instructions: String
+
+          # The type of the object. Always `choice`.
+          attr_accessor type: :choice
+
+          attr_reader name: String?
+
+          def name=: (String) -> String
+
+          # @param type
+          #   The type of the object. Always `choice`.
+          def initialize: (
+            choices: ::Array[OpenAI::DecisionCreateParams::Question::Choice::Choice],
+            instructions: String,
+            ?name: String,
+            ?type: :choice
+          ) -> void
+
+          def to_hash: -> {
+            choices: ::Array[OpenAI::DecisionCreateParams::Question::Choice::Choice],
+            instructions: String,
+            ?type: :choice,
+            ?name: String
+          }
+
+          type choice =
+            {
+              value: OpenAI::Models::DecisionCreateParams::Question::Choice::Choice::value,
+              ?description: String
+            }
+
+          class Choice < OpenAI::Internal::Type::BaseModel
+            # Choice values are typed: a string and a boolean with the same text are distinct.
+            attr_accessor value: OpenAI::Models::DecisionCreateParams::Question::Choice::Choice::value
+
+            attr_reader description: String?
+
+            def description=: (String) -> String
+
+            # @param value
+            #   Choice values are typed: a string and a boolean with the same text are distinct.
+            def initialize: (
+              value: OpenAI::Models::DecisionCreateParams::Question::Choice::Choice::value,
+              ?description: String
+            ) -> void
+
+            def to_hash: -> {
+              value: OpenAI::Models::DecisionCreateParams::Question::Choice::Choice::value,
+              ?description: String
+            }
+
+            type value = String | bool
+
+            module Value
+              extend OpenAI::Internal::Type::Union
+
+              def self?.variants: -> ::Array[OpenAI::Models::DecisionCreateParams::Question::Choice::Choice::value]
+            end
+          end
+        end
+
+        type score =
+          {
+            instructions: String,
+            levels: ::Array[OpenAI::DecisionCreateParams::Question::Score::Level],
+            ?type: :score,
+            ?name: String
+          }
+
+        class Score < OpenAI::Internal::Type::BaseModel
+          attr_accessor instructions: String
+
+          attr_accessor levels: ::Array[OpenAI::DecisionCreateParams::Question::Score::Level]
+
+          # The type of the object. Always `score`.
+          attr_accessor type: :score
+
+          attr_reader name: String?
+
+          def name=: (String) -> String
+
+          # @param type
+          #   The type of the object. Always `score`.
+          def initialize: (
+            instructions: String,
+            levels: ::Array[OpenAI::DecisionCreateParams::Question::Score::Level],
+            ?name: String,
+            ?type: :score
+          ) -> void
+
+          def to_hash: -> {
+            instructions: String,
+            levels: ::Array[OpenAI::DecisionCreateParams::Question::Score::Level],
+            ?type: :score,
+            ?name: String
+          }
+
+          type level = { label: String, ?description: String }
+
+          class Level < OpenAI::Internal::Type::BaseModel
+            attr_accessor label: String
+
+            attr_reader description: String?
+
+            def description=: (String) -> String
+
+            def initialize: (label: String, ?description: String) -> void
+
+            def to_hash: -> { label: String, ?description: String }
+          end
+        end
+
+        def self?.variants: -> ::Array[OpenAI::Models::DecisionCreateParams::question]
+      end
+    end
+  end
+end

data/sig/openai/models/decision_input_image.rbs

@@ -0,0 +1,51 @@
+module OpenAI
+  module Models
+    type decision_input_image =
+      {
+        image_url: String,
+        ?type: :input_image,
+        ?detail: OpenAI::Models::DecisionInputImage::detail?
+      }
+
+    class DecisionInputImage < OpenAI::Internal::Type::BaseModel
+      # A base64-encoded image in a data URL.
+      attr_accessor image_url: String
+
+      attr_accessor type: :input_image
+
+      # The image detail level, using the selected model's image profile. Defaults to
+      # auto.
+      attr_accessor detail: OpenAI::Models::DecisionInputImage::detail?
+
+      # @param image_url
+      #   A base64-encoded image in a data URL.
+      # @param detail
+      #   The image detail level, using the selected model's image profile. Defaults to
+      #   auto.
+      def initialize: (
+        image_url: String,
+        ?detail: OpenAI::Models::DecisionInputImage::detail?,
+        ?type: :input_image
+      ) -> void
+
+      def to_hash: -> {
+        image_url: String,
+        ?type: :input_image,
+        ?detail: OpenAI::Models::DecisionInputImage::detail?
+      }
+
+      type detail = :low | :high | :auto | :original
+
+      module Detail
+        extend OpenAI::Internal::Type::Enum
+
+        LOW: :low
+        HIGH: :high
+        AUTO: :auto
+        ORIGINAL: :original
+
+        def self?.values: -> ::Array[OpenAI::Models::DecisionInputImage::detail]
+      end
+    end
+  end
+end

data/sig/openai/models/decision_input_message.rbs

@@ -0,0 +1,57 @@
+module OpenAI
+  module Models
+    type decision_input_message =
+      {
+        content: OpenAI::Models::DecisionInputMessage::content,
+        ?role: :user,
+        ?type: OpenAI::Models::DecisionInputMessage::type_
+      }
+
+    class DecisionInputMessage < OpenAI::Internal::Type::BaseModel
+      # Text evidence or an ordered list of text and inline image parts.
+      attr_accessor content: OpenAI::Models::DecisionInputMessage::content
+
+      attr_accessor role: :user
+
+      attr_reader type: OpenAI::Models::DecisionInputMessage::type_?
+
+      def type=: (
+        OpenAI::Models::DecisionInputMessage::type_
+      ) -> OpenAI::Models::DecisionInputMessage::type_
+
+      # @param content
+      #   Text evidence or an ordered list of text and inline image parts.
+      def initialize: (
+        content: OpenAI::Models::DecisionInputMessage::content,
+        ?type: OpenAI::Models::DecisionInputMessage::type_,
+        ?role: :user
+      ) -> void
+
+      def to_hash: -> {
+        content: OpenAI::Models::DecisionInputMessage::content,
+        ?role: :user,
+        ?type: OpenAI::Models::DecisionInputMessage::type_
+      }
+
+      type content = String | ::Array[OpenAI::Models::decision_input_part]
+
+      module Content
+        extend OpenAI::Internal::Type::Union
+
+        def self?.variants: -> ::Array[OpenAI::Models::DecisionInputMessage::content]
+
+        DecisionInputPartArray: OpenAI::Internal::Type::Converter
+      end
+
+      type type_ = :message
+
+      module Type
+        extend OpenAI::Internal::Type::Enum
+
+        MESSAGE: :message
+
+        def self?.values: -> ::Array[OpenAI::Models::DecisionInputMessage::type_]
+      end
+    end
+  end
+end

data/sig/openai/models/decision_input_part.rbs

@@ -0,0 +1,12 @@
+module OpenAI
+  module Models
+    type decision_input_part =
+      OpenAI::DecisionInputText | OpenAI::DecisionInputImage
+
+    module DecisionInputPart
+      extend OpenAI::Internal::Type::Union
+
+      def self?.variants: -> ::Array[OpenAI::Models::decision_input_part]
+    end
+  end
+end

data/sig/openai/models/decision_input_text.rbs

@@ -0,0 +1,15 @@
+module OpenAI
+  module Models
+    type decision_input_text = { text: String, ?type: :input_text }
+
+    class DecisionInputText < OpenAI::Internal::Type::BaseModel
+      attr_accessor text: String
+
+      attr_accessor type: :input_text
+
+      def initialize: (text: String, ?type: :input_text) -> void
+
+      def to_hash: -> { text: String, ?type: :input_text }
+    end
+  end
+end

data/sig/openai/models/error_object.rbs

@@ -44,6 +44,7 @@ module OpenAI
         {
           ?detailed_explanation: String,
           ?error_type: OpenAI::Models::ErrorObject::Misalignment::error_type,
+          ?review_target: String?,
           ?steer: OpenAI::ErrorObject::Misalignment::Steer
         }
 
@@ -62,6 +63,10 @@ module OpenAI
           OpenAI::Models::ErrorObject::Misalignment::error_type
         ) -> OpenAI::Models::ErrorObject::Misalignment::error_type
 
+        # An opaque target for explicitly continuing this review, or null when
+        # unavailable.
+        attr_accessor review_target: String?
+
         # An optional public continuation instruction.
         attr_reader steer: OpenAI::ErrorObject::Misalignment::Steer?
 
@@ -74,17 +79,22 @@ module OpenAI
         #   The public explanation for this block.
         # @param error_type
         #   An optional classification; clients must accept additional values.
+        # @param review_target
+        #   An opaque target for explicitly continuing this review, or null when
+        #   unavailable.
         # @param steer
         #   An optional public continuation instruction.
         def initialize: (
           ?detailed_explanation: String,
           ?error_type: OpenAI::Models::ErrorObject::Misalignment::error_type,
+          ?review_target: String?,
           ?steer: OpenAI::ErrorObject::Misalignment::Steer
         ) -> void
 
         def to_hash: -> {
           ?detailed_explanation: String,
           ?error_type: OpenAI::Models::ErrorObject::Misalignment::error_type,
+          ?review_target: String?,
           ?steer: OpenAI::ErrorObject::Misalignment::Steer
         }