openai 0.99.0 → 0.101.0

data/lib/openai/models/decision.rb

@@ -0,0 +1,313 @@
+# frozen_string_literal: true
+
+module OpenAI
+  module Models
+    # @see OpenAI::Resources::Decisions#create
+    class Decision < OpenAI::Internal::Type::BaseModel
+      # @!attribute answers
+      #
+      #   @return [Array<OpenAI::Models::Decision::Answer::Predicate, OpenAI::Models::Decision::Answer::Choice, OpenAI::Models::Decision::Answer::Score, OpenAI::Models::Decision::Answer::Refusal>]
+      required :answers, -> { OpenAI::Internal::Type::ArrayOf[union: OpenAI::Decision::Answer] }
+
+      # @!attribute model
+      #
+      #   @return [String]
+      required :model, String
+
+      # @!attribute usage
+      #
+      #   @return [OpenAI::Models::Decision::Usage]
+      required :usage, -> { OpenAI::Decision::Usage }
+
+      # @!method initialize(answers:, model:, usage:)
+      #   @param answers [Array<OpenAI::Models::Decision::Answer::Predicate, OpenAI::Models::Decision::Answer::Choice, OpenAI::Models::Decision::Answer::Score, OpenAI::Models::Decision::Answer::Refusal>]
+      #   @param model [String]
+      #   @param usage [OpenAI::Models::Decision::Usage]
+
+      # A completed question always includes its name, including null when unnamed.
+      module Answer
+        extend OpenAI::Internal::Type::Union
+
+        discriminator :type
+
+        variant :predicate, -> { OpenAI::Decision::Answer::Predicate }
+
+        variant :choice, -> { OpenAI::Decision::Answer::Choice }
+
+        variant :score, -> { OpenAI::Decision::Answer::Score }
+
+        # The host may decline one question without disclosing its refusal score.
+        variant :refusal, -> { OpenAI::Decision::Answer::Refusal }
+
+        class Predicate < OpenAI::Internal::Type::BaseModel
+          # @!attribute name
+          #
+          #   @return [String, nil]
+          required :name, String, nil?: true
+
+          # @!attribute probability
+          #
+          #   @return [Float]
+          required :probability, Float
+
+          # @!attribute type
+          #   The type of the object. Always `predicate`.
+          #
+          #   @return [Symbol, :predicate]
+          required :type, const: :predicate
+
+          # @!method initialize(name:, probability:, type: :predicate)
+          #   @param name [String, nil]
+          #
+          #   @param probability [Float]
+          #
+          #   @param type [Symbol, :predicate]
+          #     The type of the object. Always `predicate`.
+        end
+
+        class Choice < OpenAI::Internal::Type::BaseModel
+          # @!attribute choice
+          #   Choice values are typed: a string and a boolean with the same text are distinct.
+          #
+          #   @return [String, Boolean]
+          required :choice, union: -> { OpenAI::Decision::Answer::Choice::Choice }
+
+          # @!attribute confidence
+          #
+          #   @return [Float]
+          required :confidence, Float
+
+          # @!attribute name
+          #
+          #   @return [String, nil]
+          required :name, String, nil?: true
+
+          # @!attribute probabilities
+          #
+          #   @return [Array<OpenAI::Models::Decision::Answer::Choice::Probability>]
+          required(
+            :probabilities,
+            -> { OpenAI::Internal::Type::ArrayOf[OpenAI::Decision::Answer::Choice::Probability] }
+          )
+
+          # @!attribute type
+          #   The type of the object. Always `choice`.
+          #
+          #   @return [Symbol, :choice]
+          required :type, const: :choice
+
+          # @!method initialize(choice:, confidence:, name:, probabilities:, type: :choice)
+          #   @param choice [String, Boolean]
+          #     Choice values are typed: a string and a boolean with the same text are distinct.
+          #
+          #   @param confidence [Float]
+          #
+          #   @param name [String, nil]
+          #
+          #   @param probabilities [Array<OpenAI::Models::Decision::Answer::Choice::Probability>]
+          #
+          #   @param type [Symbol, :choice]
+          #     The type of the object. Always `choice`.
+
+          # Choice values are typed: a string and a boolean with the same text are distinct.
+          #
+          # @see OpenAI::Models::Decision::Answer::Choice#choice
+          module Choice
+            extend OpenAI::Internal::Type::Union
+
+            variant String
+
+            variant OpenAI::Internal::Type::Boolean
+
+            # @!method self.variants
+            #   @return [Array(String, Boolean)]
+          end
+
+          class Probability < OpenAI::Internal::Type::BaseModel
+            # @!attribute probability
+            #
+            #   @return [Float]
+            required :probability, Float
+
+            # @!attribute value
+            #   Choice values are typed: a string and a boolean with the same text are distinct.
+            #
+            #   @return [String, Boolean]
+            required :value, union: -> { OpenAI::Decision::Answer::Choice::Probability::Value }
+
+            # @!method initialize(probability:, value:)
+            #   @param probability [Float]
+            #
+            #   @param value [String, Boolean]
+            #     Choice values are typed: a string and a boolean with the same text are distinct.
+
+            # Choice values are typed: a string and a boolean with the same text are distinct.
+            #
+            # @see OpenAI::Models::Decision::Answer::Choice::Probability#value
+            module Value
+              extend OpenAI::Internal::Type::Union
+
+              variant String
+
+              variant OpenAI::Internal::Type::Boolean
+
+              # @!method self.variants
+              #   @return [Array(String, Boolean)]
+            end
+          end
+        end
+
+        class Score < OpenAI::Internal::Type::BaseModel
+          # @!attribute confidence
+          #
+          #   @return [Float]
+          required :confidence, Float
+
+          # @!attribute name
+          #
+          #   @return [String, nil]
+          required :name, String, nil?: true
+
+          # @!attribute probabilities
+          #
+          #   @return [Array<OpenAI::Models::Decision::Answer::Score::Probability>]
+          required(
+            :probabilities,
+            -> { OpenAI::Internal::Type::ArrayOf[OpenAI::Decision::Answer::Score::Probability] }
+          )
+
+          # @!attribute score
+          #
+          #   @return [Float]
+          required :score, Float
+
+          # @!attribute type
+          #   The type of the object. Always `score`.
+          #
+          #   @return [Symbol, :score]
+          required :type, const: :score
+
+          # @!method initialize(confidence:, name:, probabilities:, score:, type: :score)
+          #   @param confidence [Float]
+          #
+          #   @param name [String, nil]
+          #
+          #   @param probabilities [Array<OpenAI::Models::Decision::Answer::Score::Probability>]
+          #
+          #   @param score [Float]
+          #
+          #   @param type [Symbol, :score]
+          #     The type of the object. Always `score`.
+          class Probability < OpenAI::Internal::Type::BaseModel
+            # @!attribute label
+            #
+            #   @return [String]
+            required :label, String
+
+            # @!attribute probability
+            #
+            #   @return [Float]
+            required :probability, Float
+
+            # @!attribute value
+            #
+            #   @return [Integer]
+            required :value, Integer
+
+            # @!method initialize(label:, probability:, value:)
+            #   @param label [String]
+            #   @param probability [Float]
+            #   @param value [Integer]
+          end
+        end
+
+        class Refusal < OpenAI::Internal::Type::BaseModel
+          # @!attribute name
+          #
+          #   @return [String, nil]
+          required :name, String, nil?: true
+
+          # @!attribute type
+          #   The type of the object. Always `refusal`.
+          #
+          #   @return [Symbol, :refusal]
+          required :type, const: :refusal
+
+          # @!method initialize(name:, type: :refusal)
+          #   The host may decline one question without disclosing its refusal score.
+          #
+          #   @param name [String, nil]
+          #
+          #   @param type [Symbol, :refusal]
+          #     The type of the object. Always `refusal`.
+        end
+
+        # @!method self.variants
+        #   @return [Array(OpenAI::Models::Decision::Answer::Predicate, OpenAI::Models::Decision::Answer::Choice, OpenAI::Models::Decision::Answer::Score, OpenAI::Models::Decision::Answer::Refusal)]
+      end
+
+      # @see OpenAI::Models::Decision#usage
+      class Usage < OpenAI::Internal::Type::BaseModel
+        # @!attribute input_tokens
+        #
+        #   @return [Integer]
+        required :input_tokens, Integer
+
+        # @!attribute input_tokens_details
+        #
+        #   @return [OpenAI::Models::Decision::Usage::InputTokensDetails]
+        required :input_tokens_details, -> { OpenAI::Decision::Usage::InputTokensDetails }
+
+        # @!attribute output_tokens
+        #
+        #   @return [Integer]
+        required :output_tokens, Integer
+
+        # @!attribute output_tokens_details
+        #
+        #   @return [OpenAI::Models::Decision::Usage::OutputTokensDetails]
+        required :output_tokens_details, -> { OpenAI::Decision::Usage::OutputTokensDetails }
+
+        # @!attribute total_tokens
+        #
+        #   @return [Integer]
+        required :total_tokens, Integer
+
+        # @!method initialize(input_tokens:, input_tokens_details:, output_tokens:, output_tokens_details:, total_tokens:)
+        #   @param input_tokens [Integer]
+        #   @param input_tokens_details [OpenAI::Models::Decision::Usage::InputTokensDetails]
+        #   @param output_tokens [Integer]
+        #   @param output_tokens_details [OpenAI::Models::Decision::Usage::OutputTokensDetails]
+        #   @param total_tokens [Integer]
+
+        # @see OpenAI::Models::Decision::Usage#input_tokens_details
+        class InputTokensDetails < OpenAI::Internal::Type::BaseModel
+          # @!attribute cache_write_tokens
+          #
+          #   @return [Integer]
+          required :cache_write_tokens, Integer
+
+          # @!attribute cached_tokens
+          #
+          #   @return [Integer]
+          required :cached_tokens, Integer
+
+          # @!method initialize(cache_write_tokens:, cached_tokens:)
+          #   @param cache_write_tokens [Integer]
+          #   @param cached_tokens [Integer]
+        end
+
+        # @see OpenAI::Models::Decision::Usage#output_tokens_details
+        class OutputTokensDetails < OpenAI::Internal::Type::BaseModel
+          # @!attribute reasoning_tokens
+          #
+          #   @return [Integer]
+          required :reasoning_tokens, Integer
+
+          # @!method initialize(reasoning_tokens:)
+          #   @param reasoning_tokens [Integer]
+        end
+      end
+    end
+  end
+end

data/lib/openai/models/decision_create_params.rb

@@ -0,0 +1,233 @@
+# frozen_string_literal: true
+
+module OpenAI
+  module Models
+    # @see OpenAI::Resources::Decisions#create
+    class DecisionCreateParams < OpenAI::Internal::Type::BaseModel
+      extend OpenAI::Internal::Type::RequestParameters::Converter
+      include OpenAI::Internal::Type::RequestParameters
+
+      # @!attribute 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.
+      #
+      #   @return [String, Array<OpenAI::Models::DecisionInputMessage>]
+      required :input, union: -> { OpenAI::DecisionCreateParams::Input }
+
+      # @!attribute model
+      #
+      #   @return [String]
+      required :model, String
+
+      # @!attribute questions
+      #
+      #   @return [Array<OpenAI::Models::DecisionCreateParams::Question::Predicate, OpenAI::Models::DecisionCreateParams::Question::Choice, OpenAI::Models::DecisionCreateParams::Question::Score>]
+      required :questions, -> { OpenAI::Internal::Type::ArrayOf[union: OpenAI::DecisionCreateParams::Question] }
+
+      # @!attribute safety_identifier
+      #   Opaque caller-provided end-user identifier, scoped by the verified org. Match
+      #   Responses' limit; this is never the authenticated user identity.
+      #
+      #   @return [String, nil]
+      optional :safety_identifier, String, nil?: true
+
+      # @!method initialize(input:, model:, questions:, safety_identifier: nil, request_options: {})
+      #   @param input [String, Array<OpenAI::Models::DecisionInputMessage>]
+      #     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 model [String]
+      #
+      #   @param questions [Array<OpenAI::Models::DecisionCreateParams::Question::Predicate, OpenAI::Models::DecisionCreateParams::Question::Choice, OpenAI::Models::DecisionCreateParams::Question::Score>]
+      #
+      #   @param safety_identifier [String, nil]
+      #     Opaque caller-provided end-user identifier, scoped by the verified org. Match
+      #     Responses' limit; this is never the authenticated user identity.
+      #
+      #   @param request_options [OpenAI::RequestOptions, Hash{Symbol=>Object}]
+
+      # 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.
+      module Input
+        extend OpenAI::Internal::Type::Union
+
+        variant String
+
+        variant -> { OpenAI::Models::DecisionCreateParams::Input::DecisionInputMessageArray }
+
+        # @!method self.variants
+        #   @return [Array(String, Array<OpenAI::Models::DecisionInputMessage>)]
+
+        # @type [OpenAI::Internal::Type::Converter]
+        DecisionInputMessageArray = OpenAI::Internal::Type::ArrayOf[-> { OpenAI::DecisionInputMessage }]
+      end
+
+      # A question about the request's input, with an optional correlation name.
+      module Question
+        extend OpenAI::Internal::Type::Union
+
+        discriminator :type
+
+        variant :predicate, -> { OpenAI::DecisionCreateParams::Question::Predicate }
+
+        variant :choice, -> { OpenAI::DecisionCreateParams::Question::Choice }
+
+        variant :score, -> { OpenAI::DecisionCreateParams::Question::Score }
+
+        class Predicate < OpenAI::Internal::Type::BaseModel
+          # @!attribute instructions
+          #
+          #   @return [String]
+          required :instructions, String
+
+          # @!attribute type
+          #   The type of the object. Always `predicate`.
+          #
+          #   @return [Symbol, :predicate]
+          required :type, const: :predicate
+
+          # @!attribute name
+          #
+          #   @return [String, nil]
+          optional :name, String
+
+          # @!method initialize(instructions:, name: nil, type: :predicate)
+          #   @param instructions [String]
+          #
+          #   @param name [String]
+          #
+          #   @param type [Symbol, :predicate]
+          #     The type of the object. Always `predicate`.
+        end
+
+        class Choice < OpenAI::Internal::Type::BaseModel
+          # @!attribute choices
+          #
+          #   @return [Array<OpenAI::Models::DecisionCreateParams::Question::Choice::Choice>]
+          required(
+            :choices,
+            -> { OpenAI::Internal::Type::ArrayOf[OpenAI::DecisionCreateParams::Question::Choice::Choice] }
+          )
+
+          # @!attribute instructions
+          #
+          #   @return [String]
+          required :instructions, String
+
+          # @!attribute type
+          #   The type of the object. Always `choice`.
+          #
+          #   @return [Symbol, :choice]
+          required :type, const: :choice
+
+          # @!attribute name
+          #
+          #   @return [String, nil]
+          optional :name, String
+
+          # @!method initialize(choices:, instructions:, name: nil, type: :choice)
+          #   @param choices [Array<OpenAI::Models::DecisionCreateParams::Question::Choice::Choice>]
+          #
+          #   @param instructions [String]
+          #
+          #   @param name [String]
+          #
+          #   @param type [Symbol, :choice]
+          #     The type of the object. Always `choice`.
+          class Choice < OpenAI::Internal::Type::BaseModel
+            # @!attribute value
+            #   Choice values are typed: a string and a boolean with the same text are distinct.
+            #
+            #   @return [String, Boolean]
+            required :value, union: -> { OpenAI::DecisionCreateParams::Question::Choice::Choice::Value }
+
+            # @!attribute description
+            #
+            #   @return [String, nil]
+            optional :description, String
+
+            # @!method initialize(value:, description: nil)
+            #   @param value [String, Boolean]
+            #     Choice values are typed: a string and a boolean with the same text are distinct.
+            #
+            #   @param description [String]
+
+            # Choice values are typed: a string and a boolean with the same text are distinct.
+            #
+            # @see OpenAI::Models::DecisionCreateParams::Question::Choice::Choice#value
+            module Value
+              extend OpenAI::Internal::Type::Union
+
+              variant String
+
+              variant OpenAI::Internal::Type::Boolean
+
+              # @!method self.variants
+              #   @return [Array(String, Boolean)]
+            end
+          end
+        end
+
+        class Score < OpenAI::Internal::Type::BaseModel
+          # @!attribute instructions
+          #
+          #   @return [String]
+          required :instructions, String
+
+          # @!attribute levels
+          #
+          #   @return [Array<OpenAI::Models::DecisionCreateParams::Question::Score::Level>]
+          required(
+            :levels,
+            -> { OpenAI::Internal::Type::ArrayOf[OpenAI::DecisionCreateParams::Question::Score::Level] }
+          )
+
+          # @!attribute type
+          #   The type of the object. Always `score`.
+          #
+          #   @return [Symbol, :score]
+          required :type, const: :score
+
+          # @!attribute name
+          #
+          #   @return [String, nil]
+          optional :name, String
+
+          # @!method initialize(instructions:, levels:, name: nil, type: :score)
+          #   @param instructions [String]
+          #
+          #   @param levels [Array<OpenAI::Models::DecisionCreateParams::Question::Score::Level>]
+          #
+          #   @param name [String]
+          #
+          #   @param type [Symbol, :score]
+          #     The type of the object. Always `score`.
+          class Level < OpenAI::Internal::Type::BaseModel
+            # @!attribute label
+            #
+            #   @return [String]
+            required :label, String
+
+            # @!attribute description
+            #
+            #   @return [String, nil]
+            optional :description, String
+
+            # @!method initialize(label:, description: nil)
+            #   @param label [String]
+            #   @param description [String]
+          end
+        end
+
+        # @!method self.variants
+        #   @return [Array(OpenAI::Models::DecisionCreateParams::Question::Predicate, OpenAI::Models::DecisionCreateParams::Question::Choice, OpenAI::Models::DecisionCreateParams::Question::Score)]
+      end
+    end
+  end
+end

data/lib/openai/models/decision_input_image.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module OpenAI
+  module Models
+    class DecisionInputImage < OpenAI::Internal::Type::BaseModel
+      # @!attribute image_url
+      #   A base64-encoded image in a data URL.
+      #
+      #   @return [String]
+      required :image_url, String
+
+      # @!attribute type
+      #
+      #   @return [Symbol, :input_image]
+      required :type, const: :input_image
+
+      # @!attribute detail
+      #   The image detail level, using the selected model's image profile. Defaults to
+      #   auto.
+      #
+      #   @return [Symbol, OpenAI::Models::DecisionInputImage::Detail, nil]
+      optional :detail, enum: -> { OpenAI::DecisionInputImage::Detail }, nil?: true
+
+      # @!method initialize(image_url:, detail: nil, type: :input_image)
+      #   An inline image. External URLs and file IDs are not supported.
+      #
+      #   @param image_url [String]
+      #     A base64-encoded image in a data URL.
+      #
+      #   @param detail [Symbol, OpenAI::Models::DecisionInputImage::Detail, nil]
+      #     The image detail level, using the selected model's image profile. Defaults to
+      #     auto.
+      #
+      #   @param type [Symbol, :input_image]
+
+      # The image detail level, using the selected model's image profile. Defaults to
+      # auto.
+      #
+      # @see OpenAI::Models::DecisionInputImage#detail
+      module Detail
+        extend OpenAI::Internal::Type::Enum
+
+        LOW = :low
+        HIGH = :high
+        AUTO = :auto
+        ORIGINAL = :original
+
+        # @!method self.values
+        #   @return [Array<Symbol>]
+      end
+    end
+  end
+end

data/lib/openai/models/decision_input_message.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module OpenAI
+  module Models
+    class DecisionInputMessage < OpenAI::Internal::Type::BaseModel
+      # @!attribute content
+      #   Text evidence or an ordered list of text and inline image parts.
+      #
+      #   @return [String, Array<OpenAI::Models::DecisionInputText, OpenAI::Models::DecisionInputImage>]
+      required :content, union: -> { OpenAI::DecisionInputMessage::Content }
+
+      # @!attribute role
+      #
+      #   @return [Symbol, :user]
+      required :role, const: :user
+
+      # @!attribute type
+      #
+      #   @return [Symbol, OpenAI::Models::DecisionInputMessage::Type, nil]
+      optional :type, enum: -> { OpenAI::DecisionInputMessage::Type }
+
+      # @!method initialize(content:, type: nil, role: :user)
+      #   A user message containing text or inline images.
+      #
+      #   @param content [String, Array<OpenAI::Models::DecisionInputText, OpenAI::Models::DecisionInputImage>]
+      #     Text evidence or an ordered list of text and inline image parts.
+      #
+      #   @param type [Symbol, OpenAI::Models::DecisionInputMessage::Type]
+      #
+      #   @param role [Symbol, :user]
+
+      # Text evidence or an ordered list of text and inline image parts.
+      #
+      # @see OpenAI::Models::DecisionInputMessage#content
+      module Content
+        extend OpenAI::Internal::Type::Union
+
+        variant String
+
+        variant -> { OpenAI::Models::DecisionInputMessage::Content::DecisionInputPartArray }
+
+        # @!method self.variants
+        #   @return [Array(String, Array<OpenAI::Models::DecisionInputText, OpenAI::Models::DecisionInputImage>)]
+
+        # @type [OpenAI::Internal::Type::Converter]
+        DecisionInputPartArray = OpenAI::Internal::Type::ArrayOf[union: -> { OpenAI::DecisionInputPart }]
+      end
+
+      # @see OpenAI::Models::DecisionInputMessage#type
+      module Type
+        extend OpenAI::Internal::Type::Enum
+
+        MESSAGE = :message
+
+        # @!method self.values
+        #   @return [Array<Symbol>]
+      end
+    end
+  end
+end

data/lib/openai/models/decision_input_part.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module OpenAI
+  module Models
+    # An inline image. External URLs and file IDs are not supported.
+    module DecisionInputPart
+      extend OpenAI::Internal::Type::Union
+
+      discriminator :type
+
+      variant :input_text, -> { OpenAI::DecisionInputText }
+
+      # An inline image. External URLs and file IDs are not supported.
+      variant :input_image, -> { OpenAI::DecisionInputImage }
+
+      # @!method self.variants
+      #   @return [Array(OpenAI::Models::DecisionInputText, OpenAI::Models::DecisionInputImage)]
+    end
+  end
+end

data/lib/openai/models/decision_input_text.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module OpenAI
+  module Models
+    class DecisionInputText < OpenAI::Internal::Type::BaseModel
+      # @!attribute text
+      #
+      #   @return [String]
+      required :text, String
+
+      # @!attribute type
+      #
+      #   @return [Symbol, :input_text]
+      required :type, const: :input_text
+
+      # @!method initialize(text:, type: :input_text)
+      #   @param text [String]
+      #   @param type [Symbol, :input_text]
+    end
+  end
+end