openai 0.100.0 → 0.101.0

data/rbi/openai/models/decision_create_params.rbi

@@ -0,0 +1,435 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    class DecisionCreateParams < OpenAI::Internal::Type::BaseModel
+
+      extend OpenAI::Internal::Type::RequestParameters::Converter
+      include OpenAI::Internal::Type::RequestParameters
+
+      OrHash = T.type_alias do
+        T.any(
+          OpenAI::DecisionCreateParams,
+          OpenAI::Internal::AnyHash
+        )
+      end
+
+      # 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.
+      sig { returns(OpenAI::DecisionCreateParams::Input::Variants) }
+      attr_accessor :input
+
+      sig { returns(String) }
+      attr_accessor :model
+
+      sig {
+        returns(
+          T::Array[
+            T.any(
+              OpenAI::DecisionCreateParams::Question::Predicate,
+              OpenAI::DecisionCreateParams::Question::Choice,
+              OpenAI::DecisionCreateParams::Question::Score
+            )
+          ]
+        )
+      }
+      attr_accessor :questions
+
+      # Opaque caller-provided end-user identifier, scoped by the verified org. Match
+      # Responses' limit; this is never the authenticated user identity.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :safety_identifier
+
+      sig do
+        params(
+
+          input: OpenAI::DecisionCreateParams::Input::Variants,
+
+          model: String,
+
+          questions: T::Array[
+            T.any(
+              OpenAI::DecisionCreateParams::Question::Predicate::OrHash,
+              OpenAI::DecisionCreateParams::Question::Choice::OrHash,
+              OpenAI::DecisionCreateParams::Question::Score::OrHash
+            )
+          ],
+
+          safety_identifier: T.nilable(String),
+
+          request_options: OpenAI::RequestOptions::OrHash
+        )
+          .returns(T.attached_class)
+      end
+      def self.new(
+
+        # 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.
+        input:,
+
+        model:,
+
+        questions:,
+
+        # Opaque caller-provided end-user identifier, scoped by the verified org. Match
+        # Responses' limit; this is never the authenticated user identity.
+        safety_identifier: nil,
+
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            input: OpenAI::DecisionCreateParams::Input::Variants,
+            model: String,
+            questions: T::Array[
+              T.any(
+                OpenAI::DecisionCreateParams::Question::Predicate,
+                OpenAI::DecisionCreateParams::Question::Choice,
+                OpenAI::DecisionCreateParams::Question::Score
+              )
+            ],
+            safety_identifier: T.nilable(String),
+            request_options: OpenAI::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+
+      # 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
+
+        Variants = T.type_alias { T.any(String, T::Array[OpenAI::DecisionInputMessage]) }
+
+        sig { override.returns(T::Array[OpenAI::DecisionCreateParams::Input::Variants]) }
+        def self.variants
+        end
+
+        DecisionInputMessageArray = T.let(
+          OpenAI::Internal::Type::ArrayOf[OpenAI::DecisionInputMessage],
+          OpenAI::Internal::Type::Converter
+        )
+
+      end
+
+      # A question about the request's input, with an optional correlation name.
+      module Question
+        extend OpenAI::Internal::Type::Union
+
+        Variants = T.type_alias {
+          T.any(
+            OpenAI::DecisionCreateParams::Question::Predicate,
+            OpenAI::DecisionCreateParams::Question::Choice,
+            OpenAI::DecisionCreateParams::Question::Score
+          )
+        }
+
+        class Predicate < OpenAI::Internal::Type::BaseModel
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::DecisionCreateParams::Question::Predicate,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+          sig { returns(String) }
+          attr_accessor :instructions
+
+          # The type of the object. Always `predicate`.
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          sig { returns(T.nilable(String)) }
+          attr_reader :name
+
+          sig { params(name: String).void }
+          attr_writer :name
+
+          sig do
+            params(
+
+              instructions: String,
+
+              name: String,
+
+              type: Symbol
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(
+
+            instructions:,
+
+            name: nil,
+
+            # The type of the object. Always `predicate`.
+
+            type: :predicate
+          )
+          end
+
+          sig do
+            override.returns(
+              {instructions: String, type: Symbol, name: String}
+            )
+          end
+          def to_hash
+          end
+
+        end
+
+        class Choice < OpenAI::Internal::Type::BaseModel
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::DecisionCreateParams::Question::Choice,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+          sig { returns(T::Array[OpenAI::DecisionCreateParams::Question::Choice::Choice]) }
+          attr_accessor :choices
+
+          sig { returns(String) }
+          attr_accessor :instructions
+
+          # The type of the object. Always `choice`.
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          sig { returns(T.nilable(String)) }
+          attr_reader :name
+
+          sig { params(name: String).void }
+          attr_writer :name
+
+          sig do
+            params(
+
+              choices: T::Array[OpenAI::DecisionCreateParams::Question::Choice::Choice::OrHash],
+
+              instructions: String,
+
+              name: String,
+
+              type: Symbol
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(
+
+            choices:,
+
+            instructions:,
+
+            name: nil,
+
+            # The type of the object. Always `choice`.
+
+            type: :choice
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                choices: T::Array[OpenAI::DecisionCreateParams::Question::Choice::Choice],
+                instructions: String,
+                type: Symbol,
+                name: String
+              }
+            )
+          end
+          def to_hash
+          end
+
+          class Choice < OpenAI::Internal::Type::BaseModel
+            OrHash = T.type_alias do
+              T.any(
+                OpenAI::DecisionCreateParams::Question::Choice::Choice,
+                OpenAI::Internal::AnyHash
+              )
+            end
+
+            # Choice values are typed: a string and a boolean with the same text are distinct.
+            sig { returns(T.any(String, T::Boolean)) }
+            attr_accessor :value
+
+            sig { returns(T.nilable(String)) }
+            attr_reader :description
+
+            sig { params(description: String).void }
+            attr_writer :description
+
+            sig do
+              params(
+
+                value: T.any(String, T::Boolean),
+
+                description: String
+              )
+                .returns(T.attached_class)
+            end
+            def self.new(
+
+              # Choice values are typed: a string and a boolean with the same text are distinct.
+              value:,
+
+              description: nil
+            )
+            end
+
+            sig do
+              override.returns(
+                {value: T.any(String, T::Boolean), description: String}
+              )
+            end
+            def to_hash
+            end
+
+            # Choice values are typed: a string and a boolean with the same text are distinct.
+            module Value
+              extend OpenAI::Internal::Type::Union
+
+              Variants = T.type_alias { T.any(String, T::Boolean) }
+
+              sig {
+                override.returns(T::Array[OpenAI::DecisionCreateParams::Question::Choice::Choice::Value::Variants])
+              }
+              def self.variants
+              end
+
+            end
+          end
+        end
+
+        class Score < OpenAI::Internal::Type::BaseModel
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::DecisionCreateParams::Question::Score,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+          sig { returns(String) }
+          attr_accessor :instructions
+
+          sig { returns(T::Array[OpenAI::DecisionCreateParams::Question::Score::Level]) }
+          attr_accessor :levels
+
+          # The type of the object. Always `score`.
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          sig { returns(T.nilable(String)) }
+          attr_reader :name
+
+          sig { params(name: String).void }
+          attr_writer :name
+
+          sig do
+            params(
+
+              instructions: String,
+
+              levels: T::Array[OpenAI::DecisionCreateParams::Question::Score::Level::OrHash],
+
+              name: String,
+
+              type: Symbol
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(
+
+            instructions:,
+
+            levels:,
+
+            name: nil,
+
+            # The type of the object. Always `score`.
+
+            type: :score
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                instructions: String,
+                levels: T::Array[OpenAI::DecisionCreateParams::Question::Score::Level],
+                type: Symbol,
+                name: String
+              }
+            )
+          end
+          def to_hash
+          end
+
+          class Level < OpenAI::Internal::Type::BaseModel
+            OrHash = T.type_alias do
+              T.any(
+                OpenAI::DecisionCreateParams::Question::Score::Level,
+                OpenAI::Internal::AnyHash
+              )
+            end
+
+            sig { returns(String) }
+            attr_accessor :label
+
+            sig { returns(T.nilable(String)) }
+            attr_reader :description
+
+            sig { params(description: String).void }
+            attr_writer :description
+
+            sig do
+              params(
+
+                label: String,
+
+                description: String
+              )
+                .returns(T.attached_class)
+            end
+            def self.new(
+
+              label:,
+
+              description: nil
+            )
+            end
+
+            sig do
+              override.returns(
+                {label: String, description: String}
+              )
+            end
+            def to_hash
+            end
+
+          end
+        end
+
+        sig { override.returns(T::Array[OpenAI::DecisionCreateParams::Question::Variants]) }
+        def self.variants
+        end
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/decision_input_image.rbi

@@ -0,0 +1,81 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    class DecisionInputImage < OpenAI::Internal::Type::BaseModel
+
+      OrHash = T.type_alias do
+        T.any(
+          OpenAI::DecisionInputImage,
+          OpenAI::Internal::AnyHash
+        )
+      end
+
+      # A base64-encoded image in a data URL.
+      sig { returns(String) }
+      attr_accessor :image_url
+
+      sig { returns(Symbol) }
+      attr_accessor :type
+
+      # The image detail level, using the selected model's image profile. Defaults to
+      # auto.
+      sig { returns(T.nilable(OpenAI::DecisionInputImage::Detail::OrSymbol)) }
+      attr_accessor :detail
+
+      # An inline image. External URLs and file IDs are not supported.
+      sig do
+        params(
+
+          image_url: String,
+
+          detail: T.nilable(OpenAI::DecisionInputImage::Detail::OrSymbol),
+
+          type: Symbol
+        )
+          .returns(T.attached_class)
+      end
+      def self.new(
+
+        # A base64-encoded image in a data URL.
+        image_url:,
+
+        # The image detail level, using the selected model's image profile. Defaults to
+        # auto.
+        detail: nil,
+
+        type: :input_image
+      )
+      end
+
+      sig do
+        override.returns(
+          {image_url: String, type: Symbol, detail: T.nilable(OpenAI::DecisionInputImage::Detail::OrSymbol)}
+        )
+      end
+      def to_hash
+      end
+
+      # The image detail level, using the selected model's image profile. Defaults to
+      # auto.
+      module Detail
+        extend OpenAI::Internal::Type::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, OpenAI::DecisionInputImage::Detail) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        LOW = T.let(:low, OpenAI::DecisionInputImage::Detail::TaggedSymbol)
+        HIGH = T.let(:high, OpenAI::DecisionInputImage::Detail::TaggedSymbol)
+        AUTO = T.let(:auto, OpenAI::DecisionInputImage::Detail::TaggedSymbol)
+        ORIGINAL = T.let(:original, OpenAI::DecisionInputImage::Detail::TaggedSymbol)
+
+        sig { override.returns(T::Array[OpenAI::DecisionInputImage::Detail::TaggedSymbol]) }
+        def self.values
+        end
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/decision_input_message.rbi

@@ -0,0 +1,96 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    class DecisionInputMessage < OpenAI::Internal::Type::BaseModel
+
+      OrHash = T.type_alias do
+        T.any(
+          OpenAI::DecisionInputMessage,
+          OpenAI::Internal::AnyHash
+        )
+      end
+
+      # Text evidence or an ordered list of text and inline image parts.
+      sig { returns(OpenAI::DecisionInputMessage::Content::Variants) }
+      attr_accessor :content
+
+      sig { returns(Symbol) }
+      attr_accessor :role
+
+      sig { returns(T.nilable(OpenAI::DecisionInputMessage::Type::OrSymbol)) }
+      attr_reader :type
+
+      sig { params(type: OpenAI::DecisionInputMessage::Type::OrSymbol).void }
+      attr_writer :type
+
+      # A user message containing text or inline images.
+      sig do
+        params(
+
+          content: OpenAI::DecisionInputMessage::Content::Variants,
+
+          type: OpenAI::DecisionInputMessage::Type::OrSymbol,
+
+          role: Symbol
+        )
+          .returns(T.attached_class)
+      end
+      def self.new(
+
+        # Text evidence or an ordered list of text and inline image parts.
+        content:,
+
+        type: nil,
+
+        role: :user
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            content: OpenAI::DecisionInputMessage::Content::Variants,
+            role: Symbol,
+            type: OpenAI::DecisionInputMessage::Type::OrSymbol
+          }
+        )
+      end
+      def to_hash
+      end
+
+      # Text evidence or an ordered list of text and inline image parts.
+      module Content
+        extend OpenAI::Internal::Type::Union
+
+        Variants = T.type_alias { T.any(String, T::Array[OpenAI::DecisionInputPart::Variants]) }
+
+        sig { override.returns(T::Array[OpenAI::DecisionInputMessage::Content::Variants]) }
+        def self.variants
+        end
+
+        DecisionInputPartArray = T.let(
+          OpenAI::Internal::Type::ArrayOf[union: OpenAI::DecisionInputPart],
+          OpenAI::Internal::Type::Converter
+        )
+
+      end
+
+      module Type
+        extend OpenAI::Internal::Type::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, OpenAI::DecisionInputMessage::Type) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        MESSAGE = T.let(:message, OpenAI::DecisionInputMessage::Type::TaggedSymbol)
+
+        sig { override.returns(T::Array[OpenAI::DecisionInputMessage::Type::TaggedSymbol]) }
+        def self.values
+        end
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/decision_input_part.rbi

@@ -0,0 +1,24 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    # An inline image. External URLs and file IDs are not supported.
+    module DecisionInputPart
+      extend OpenAI::Internal::Type::Union
+
+      Variants = T.type_alias do
+        T.any(
+          OpenAI::DecisionInputText,
+          OpenAI::DecisionInputImage
+        )
+      end
+
+      sig { override.returns(T::Array[OpenAI::DecisionInputPart::Variants]) }
+      def self.variants
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/decision_input_text.rbi

@@ -0,0 +1,49 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    class DecisionInputText < OpenAI::Internal::Type::BaseModel
+
+      OrHash = T.type_alias do
+        T.any(
+          OpenAI::DecisionInputText,
+          OpenAI::Internal::AnyHash
+        )
+      end
+
+      sig { returns(String) }
+      attr_accessor :text
+
+      sig { returns(Symbol) }
+      attr_accessor :type
+
+      sig do
+        params(
+
+          text: String,
+
+          type: Symbol
+        )
+          .returns(T.attached_class)
+      end
+      def self.new(
+
+        text:,
+
+        type: :input_text
+      )
+      end
+
+      sig do
+        override.returns(
+          {text: String, type: Symbol}
+        )
+      end
+      def to_hash
+      end
+
+    end
+
+  end
+end