openai 0.100.0 → 0.101.0

data/sig/openai/models/beta/beta_tool_search_output_namespace_tool.rbs

@@ -0,0 +1,162 @@
+module OpenAI
+  module Models
+    class BetaToolSearchOutputNamespaceTool = Beta::BetaToolSearchOutputNamespaceTool
+
+    module Beta
+      type beta_tool_search_output_namespace_tool =
+        {
+          description: String,
+          name: String,
+          tools: ::Array[OpenAI::Models::Beta::BetaToolSearchOutputNamespaceTool::tool],
+          ?type: :namespace
+        }
+
+      class BetaToolSearchOutputNamespaceTool < OpenAI::Internal::Type::BaseModel
+        # A description of the namespace shown to the model.
+        attr_accessor description: String
+
+        # The namespace name used in tool calls (for example, `crm`).
+        attr_accessor name: String
+
+        # The function/custom tools loaded inside this namespace.
+        attr_accessor tools: ::Array[OpenAI::Models::Beta::BetaToolSearchOutputNamespaceTool::tool]
+
+        # The type of the tool. Always `namespace`.
+        attr_accessor type: :namespace
+
+        # @param description
+        #   A description of the namespace shown to the model.
+        # @param name
+        #   The namespace name used in tool calls (for example, `crm`).
+        # @param tools
+        #   The function/custom tools loaded inside this namespace.
+        # @param type
+        #   The type of the tool. Always `namespace`.
+        def initialize: (
+          description: String,
+          name: String,
+          tools: ::Array[OpenAI::Models::Beta::BetaToolSearchOutputNamespaceTool::tool],
+          ?type: :namespace
+        ) -> void
+
+        def to_hash: -> {
+          description: String,
+          name: String,
+          tools: ::Array[OpenAI::Models::Beta::BetaToolSearchOutputNamespaceTool::tool],
+          ?type: :namespace
+        }
+
+        type tool =
+          OpenAI::Beta::BetaToolSearchOutputNamespaceTool::Tool::Function
+          | OpenAI::Beta::BetaCustomTool
+
+        module Tool
+          extend OpenAI::Internal::Type::Union
+
+          type function =
+            {
+              name: String,
+              ?type: :function,
+              ?allowed_callers: ::Array[OpenAI::Models::Beta::BetaToolSearchOutputNamespaceTool::Tool::Function::allowed_caller]?,
+              ?async: bool,
+              ?defer_loading: bool,
+              ?description: String?,
+              ?output_schema: ::Hash[Symbol, top]?,
+              ?parameters: top?,
+              ?strict: bool?
+            }
+
+          class Function < OpenAI::Internal::Type::BaseModel
+            # The name of the loaded function tool.
+            attr_accessor name: String
+
+            attr_accessor type: :function
+
+            # The tool invocation context(s).
+            attr_accessor allowed_callers: ::Array[OpenAI::Models::Beta::BetaToolSearchOutputNamespaceTool::Tool::Function::allowed_caller]?
+
+            # Whether the tool response can be returned asynchronously versus immediately
+            # returned on next response creation.
+            attr_reader async: bool?
+
+            # Whether the tool response can be returned asynchronously versus immediately
+            # returned on next response creation.
+            def async=: (bool) -> bool
+
+            # Whether this function should be deferred and discovered via tool search.
+            attr_reader defer_loading: bool?
+
+            # Whether this function should be deferred and discovered via tool search.
+            def defer_loading=: (bool) -> bool
+
+            attr_accessor description: String?
+
+            # A JSON Schema describing the JSON value encoded in string outputs for this
+            # function tool. This does not describe content-array outputs.
+            attr_accessor output_schema: ::Hash[Symbol, top]?
+
+            attr_accessor parameters: top?
+
+            # 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.
+            attr_accessor strict: bool?
+
+            # @param name
+            #   The name of the loaded function tool.
+            # @param allowed_callers
+            #   The tool invocation context(s).
+            # @param async
+            #   Whether the tool response can be returned asynchronously versus immediately
+            #   returned on next response creation.
+            # @param defer_loading
+            #   Whether this function should be deferred and discovered via tool search.
+            # @param output_schema
+            #   A JSON Schema describing the JSON value encoded in string outputs for this
+            #   function tool. This does not describe content-array outputs.
+            # @param strict
+            #   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.
+            def initialize: (
+              name: String,
+              ?allowed_callers: ::Array[OpenAI::Models::Beta::BetaToolSearchOutputNamespaceTool::Tool::Function::allowed_caller]?,
+              ?async: bool,
+              ?defer_loading: bool,
+              ?description: String?,
+              ?output_schema: ::Hash[Symbol, top]?,
+              ?parameters: top?,
+              ?strict: bool?,
+              ?type: :function
+            ) -> void
+
+            def to_hash: -> {
+              name: String,
+              ?type: :function,
+              ?allowed_callers: ::Array[OpenAI::Models::Beta::BetaToolSearchOutputNamespaceTool::Tool::Function::allowed_caller]?,
+              ?async: bool,
+              ?defer_loading: bool,
+              ?description: String?,
+              ?output_schema: ::Hash[Symbol, top]?,
+              ?parameters: top?,
+              ?strict: bool?
+            }
+
+            type allowed_caller = :direct | :programmatic
+
+            module AllowedCaller
+              extend OpenAI::Internal::Type::Enum
+
+              DIRECT: :direct
+              PROGRAMMATIC: :programmatic
+
+              def self?.values: -> ::Array[OpenAI::Models::Beta::BetaToolSearchOutputNamespaceTool::Tool::Function::allowed_caller]
+            end
+          end
+
+          def self?.variants: -> ::Array[OpenAI::Models::Beta::BetaToolSearchOutputNamespaceTool::tool]
+        end
+      end
+    end
+  end
+end

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