openai 0.67.0 → 0.69.0

data/rbi/openai/models/beta/beta_response_file_search_tool_call.rbi

@@ -0,0 +1,328 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    BetaResponseFileSearchToolCall = Beta::BetaResponseFileSearchToolCall
+
+    module Beta
+      class BetaResponseFileSearchToolCall < OpenAI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              OpenAI::Beta::BetaResponseFileSearchToolCall,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+        # The unique ID of the file search tool call.
+        sig { returns(String) }
+        attr_accessor :id
+
+        # The queries used to search for files.
+        sig { returns(T::Array[String]) }
+        attr_accessor :queries
+
+        # The status of the file search tool call. One of `in_progress`, `searching`,
+        # `incomplete` or `failed`,
+        sig do
+          returns(
+            OpenAI::Beta::BetaResponseFileSearchToolCall::Status::OrSymbol
+          )
+        end
+        attr_accessor :status
+
+        # The type of the file search tool call. Always `file_search_call`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # The agent that produced this item.
+        sig do
+          returns(
+            T.nilable(OpenAI::Beta::BetaResponseFileSearchToolCall::Agent)
+          )
+        end
+        attr_reader :agent
+
+        sig do
+          params(
+            agent:
+              T.nilable(
+                OpenAI::Beta::BetaResponseFileSearchToolCall::Agent::OrHash
+              )
+          ).void
+        end
+        attr_writer :agent
+
+        # The results of the file search tool call.
+        sig do
+          returns(
+            T.nilable(
+              T::Array[OpenAI::Beta::BetaResponseFileSearchToolCall::Result]
+            )
+          )
+        end
+        attr_accessor :results
+
+        # The results of a file search tool call. See the
+        # [file search guide](https://platform.openai.com/docs/guides/tools-file-search)
+        # for more information.
+        sig do
+          params(
+            id: String,
+            queries: T::Array[String],
+            status:
+              OpenAI::Beta::BetaResponseFileSearchToolCall::Status::OrSymbol,
+            agent:
+              T.nilable(
+                OpenAI::Beta::BetaResponseFileSearchToolCall::Agent::OrHash
+              ),
+            results:
+              T.nilable(
+                T::Array[
+                  OpenAI::Beta::BetaResponseFileSearchToolCall::Result::OrHash
+                ]
+              ),
+            type: Symbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # The unique ID of the file search tool call.
+          id:,
+          # The queries used to search for files.
+          queries:,
+          # The status of the file search tool call. One of `in_progress`, `searching`,
+          # `incomplete` or `failed`,
+          status:,
+          # The agent that produced this item.
+          agent: nil,
+          # The results of the file search tool call.
+          results: nil,
+          # The type of the file search tool call. Always `file_search_call`.
+          type: :file_search_call
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              id: String,
+              queries: T::Array[String],
+              status:
+                OpenAI::Beta::BetaResponseFileSearchToolCall::Status::OrSymbol,
+              type: Symbol,
+              agent:
+                T.nilable(OpenAI::Beta::BetaResponseFileSearchToolCall::Agent),
+              results:
+                T.nilable(
+                  T::Array[OpenAI::Beta::BetaResponseFileSearchToolCall::Result]
+                )
+            }
+          )
+        end
+        def to_hash
+        end
+
+        # The status of the file search tool call. One of `in_progress`, `searching`,
+        # `incomplete` or `failed`,
+        module Status
+          extend OpenAI::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(
+                Symbol,
+                OpenAI::Beta::BetaResponseFileSearchToolCall::Status
+              )
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          IN_PROGRESS =
+            T.let(
+              :in_progress,
+              OpenAI::Beta::BetaResponseFileSearchToolCall::Status::TaggedSymbol
+            )
+          SEARCHING =
+            T.let(
+              :searching,
+              OpenAI::Beta::BetaResponseFileSearchToolCall::Status::TaggedSymbol
+            )
+          COMPLETED =
+            T.let(
+              :completed,
+              OpenAI::Beta::BetaResponseFileSearchToolCall::Status::TaggedSymbol
+            )
+          INCOMPLETE =
+            T.let(
+              :incomplete,
+              OpenAI::Beta::BetaResponseFileSearchToolCall::Status::TaggedSymbol
+            )
+          FAILED =
+            T.let(
+              :failed,
+              OpenAI::Beta::BetaResponseFileSearchToolCall::Status::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                OpenAI::Beta::BetaResponseFileSearchToolCall::Status::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+
+        class Agent < OpenAI::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                OpenAI::Beta::BetaResponseFileSearchToolCall::Agent,
+                OpenAI::Internal::AnyHash
+              )
+            end
+
+          # The canonical name of the agent that produced this item.
+          sig { returns(String) }
+          attr_accessor :agent_name
+
+          # The agent that produced this item.
+          sig { params(agent_name: String).returns(T.attached_class) }
+          def self.new(
+            # The canonical name of the agent that produced this item.
+            agent_name:
+          )
+          end
+
+          sig { override.returns({ agent_name: String }) }
+          def to_hash
+          end
+        end
+
+        class Result < OpenAI::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                OpenAI::Beta::BetaResponseFileSearchToolCall::Result,
+                OpenAI::Internal::AnyHash
+              )
+            end
+
+          # Set of 16 key-value pairs that can be attached to an object. This can be useful
+          # for storing additional information about the object in a structured format, and
+          # querying for objects via API or the dashboard. Keys are strings with a maximum
+          # length of 64 characters. Values are strings with a maximum length of 512
+          # characters, booleans, or numbers.
+          sig do
+            returns(
+              T.nilable(
+                T::Hash[
+                  Symbol,
+                  OpenAI::Beta::BetaResponseFileSearchToolCall::Result::Attribute::Variants
+                ]
+              )
+            )
+          end
+          attr_accessor :attributes
+
+          # The unique ID of the file.
+          sig { returns(T.nilable(String)) }
+          attr_reader :file_id
+
+          sig { params(file_id: String).void }
+          attr_writer :file_id
+
+          # The name of the file.
+          sig { returns(T.nilable(String)) }
+          attr_reader :filename
+
+          sig { params(filename: String).void }
+          attr_writer :filename
+
+          # The relevance score of the file - a value between 0 and 1.
+          sig { returns(T.nilable(Float)) }
+          attr_reader :score
+
+          sig { params(score: Float).void }
+          attr_writer :score
+
+          # The text that was retrieved from the file.
+          sig { returns(T.nilable(String)) }
+          attr_reader :text
+
+          sig { params(text: String).void }
+          attr_writer :text
+
+          sig do
+            params(
+              attributes:
+                T.nilable(
+                  T::Hash[
+                    Symbol,
+                    OpenAI::Beta::BetaResponseFileSearchToolCall::Result::Attribute::Variants
+                  ]
+                ),
+              file_id: String,
+              filename: String,
+              score: Float,
+              text: String
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            # Set of 16 key-value pairs that can be attached to an object. This can be useful
+            # for storing additional information about the object in a structured format, and
+            # querying for objects via API or the dashboard. Keys are strings with a maximum
+            # length of 64 characters. Values are strings with a maximum length of 512
+            # characters, booleans, or numbers.
+            attributes: nil,
+            # The unique ID of the file.
+            file_id: nil,
+            # The name of the file.
+            filename: nil,
+            # The relevance score of the file - a value between 0 and 1.
+            score: nil,
+            # The text that was retrieved from the file.
+            text: nil
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                attributes:
+                  T.nilable(
+                    T::Hash[
+                      Symbol,
+                      OpenAI::Beta::BetaResponseFileSearchToolCall::Result::Attribute::Variants
+                    ]
+                  ),
+                file_id: String,
+                filename: String,
+                score: Float,
+                text: String
+              }
+            )
+          end
+          def to_hash
+          end
+
+          module Attribute
+            extend OpenAI::Internal::Type::Union
+
+            Variants = T.type_alias { T.any(String, Float, T::Boolean) }
+
+            sig do
+              override.returns(
+                T::Array[
+                  OpenAI::Beta::BetaResponseFileSearchToolCall::Result::Attribute::Variants
+                ]
+              )
+            end
+            def self.variants
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/openai/models/beta/beta_response_format_text_config.rbi

@@ -0,0 +1,97 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    BetaResponseFormatTextConfig = Beta::BetaResponseFormatTextConfig
+
+    module Beta
+      # An object specifying the format that the model must output.
+      #
+      # Configuring `{ "type": "json_schema" }` enables Structured Outputs, which
+      # ensures the model will match your supplied JSON schema. Learn more in the
+      # [Structured Outputs guide](https://platform.openai.com/docs/guides/structured-outputs).
+      #
+      # The default format is `{ "type": "text" }` with no additional options.
+      #
+      # **Not recommended for gpt-4o and newer models:**
+      #
+      # Setting to `{ "type": "json_object" }` enables the older JSON mode, which
+      # ensures the message the model generates is valid JSON. Using `json_schema` is
+      # preferred for models that support it.
+      module BetaResponseFormatTextConfig
+        extend OpenAI::Internal::Type::Union
+
+        Variants =
+          T.type_alias do
+            T.any(
+              OpenAI::Beta::BetaResponseFormatTextConfig::Text,
+              OpenAI::Beta::BetaResponseFormatTextJSONSchemaConfig,
+              OpenAI::Beta::BetaResponseFormatTextConfig::JSONObject
+            )
+          end
+
+        class Text < OpenAI::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                OpenAI::Beta::BetaResponseFormatTextConfig::Text,
+                OpenAI::Internal::AnyHash
+              )
+            end
+
+          # The type of response format being defined. Always `text`.
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          # Default response format. Used to generate text responses.
+          sig { params(type: Symbol).returns(T.attached_class) }
+          def self.new(
+            # The type of response format being defined. Always `text`.
+            type: :text
+          )
+          end
+
+          sig { override.returns({ type: Symbol }) }
+          def to_hash
+          end
+        end
+
+        class JSONObject < OpenAI::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                OpenAI::Beta::BetaResponseFormatTextConfig::JSONObject,
+                OpenAI::Internal::AnyHash
+              )
+            end
+
+          # The type of response format being defined. Always `json_object`.
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          # JSON object response format. An older method of generating JSON responses. Using
+          # `json_schema` is recommended for models that support it. Note that the model
+          # will not generate JSON without a system or user message instructing it to do so.
+          sig { params(type: Symbol).returns(T.attached_class) }
+          def self.new(
+            # The type of response format being defined. Always `json_object`.
+            type: :json_object
+          )
+          end
+
+          sig { override.returns({ type: Symbol }) }
+          def to_hash
+          end
+        end
+
+        sig do
+          override.returns(
+            T::Array[OpenAI::Beta::BetaResponseFormatTextConfig::Variants]
+          )
+        end
+        def self.variants
+        end
+      end
+    end
+  end
+end

data/rbi/openai/models/beta/beta_response_format_text_json_schema_config.rbi

@@ -0,0 +1,97 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    BetaResponseFormatTextJSONSchemaConfig =
+      Beta::BetaResponseFormatTextJSONSchemaConfig
+
+    module Beta
+      class BetaResponseFormatTextJSONSchemaConfig < OpenAI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              OpenAI::Beta::BetaResponseFormatTextJSONSchemaConfig,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+        # The name of the response format. Must be a-z, A-Z, 0-9, or contain underscores
+        # and dashes, with a maximum length of 64.
+        sig { returns(String) }
+        attr_accessor :name
+
+        # The schema for the response format, described as a JSON Schema object. Learn how
+        # to build JSON schemas [here](https://json-schema.org/).
+        sig { returns(T::Hash[Symbol, T.anything]) }
+        attr_accessor :schema
+
+        # The type of response format being defined. Always `json_schema`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # A description of what the response format is for, used by the model to determine
+        # how to respond in the format.
+        sig { returns(T.nilable(String)) }
+        attr_reader :description
+
+        sig { params(description: String).void }
+        attr_writer :description
+
+        # Whether to enable strict schema adherence when generating the output. If set to
+        # true, the model will always follow the exact schema defined in the `schema`
+        # field. Only a subset of JSON Schema is supported when `strict` is `true`. To
+        # learn more, read the
+        # [Structured Outputs guide](https://platform.openai.com/docs/guides/structured-outputs).
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_accessor :strict
+
+        # JSON Schema response format. Used to generate structured JSON responses. Learn
+        # more about
+        # [Structured Outputs](https://platform.openai.com/docs/guides/structured-outputs).
+        sig do
+          params(
+            name: String,
+            schema: T::Hash[Symbol, T.anything],
+            description: String,
+            strict: T.nilable(T::Boolean),
+            type: Symbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # The name of the response format. Must be a-z, A-Z, 0-9, or contain underscores
+          # and dashes, with a maximum length of 64.
+          name:,
+          # The schema for the response format, described as a JSON Schema object. Learn how
+          # to build JSON schemas [here](https://json-schema.org/).
+          schema:,
+          # A description of what the response format is for, used by the model to determine
+          # how to respond in the format.
+          description: nil,
+          # Whether to enable strict schema adherence when generating the output. If set to
+          # true, the model will always follow the exact schema defined in the `schema`
+          # field. Only a subset of JSON Schema is supported when `strict` is `true`. To
+          # learn more, read the
+          # [Structured Outputs guide](https://platform.openai.com/docs/guides/structured-outputs).
+          strict: nil,
+          # The type of response format being defined. Always `json_schema`.
+          type: :json_schema
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              name: String,
+              schema: T::Hash[Symbol, T.anything],
+              type: Symbol,
+              description: String,
+              strict: T.nilable(T::Boolean)
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/openai/models/beta/beta_response_function_call_arguments_delta_event.rbi

@@ -0,0 +1,134 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    BetaResponseFunctionCallArgumentsDeltaEvent =
+      Beta::BetaResponseFunctionCallArgumentsDeltaEvent
+
+    module Beta
+      class BetaResponseFunctionCallArgumentsDeltaEvent < OpenAI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              OpenAI::Beta::BetaResponseFunctionCallArgumentsDeltaEvent,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+        # The function-call arguments delta that is added.
+        sig { returns(String) }
+        attr_accessor :delta
+
+        # The ID of the output item that the function-call arguments delta is added to.
+        sig { returns(String) }
+        attr_accessor :item_id
+
+        # The index of the output item that the function-call arguments delta is added to.
+        sig { returns(Integer) }
+        attr_accessor :output_index
+
+        # The sequence number of this event.
+        sig { returns(Integer) }
+        attr_accessor :sequence_number
+
+        # The type of the event. Always `response.function_call_arguments.delta`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # The agent that owns this multi-agent streaming event.
+        sig do
+          returns(
+            T.nilable(
+              OpenAI::Beta::BetaResponseFunctionCallArgumentsDeltaEvent::Agent
+            )
+          )
+        end
+        attr_reader :agent
+
+        sig do
+          params(
+            agent:
+              T.nilable(
+                OpenAI::Beta::BetaResponseFunctionCallArgumentsDeltaEvent::Agent::OrHash
+              )
+          ).void
+        end
+        attr_writer :agent
+
+        # Emitted when there is a partial function-call arguments delta.
+        sig do
+          params(
+            delta: String,
+            item_id: String,
+            output_index: Integer,
+            sequence_number: Integer,
+            agent:
+              T.nilable(
+                OpenAI::Beta::BetaResponseFunctionCallArgumentsDeltaEvent::Agent::OrHash
+              ),
+            type: Symbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # The function-call arguments delta that is added.
+          delta:,
+          # The ID of the output item that the function-call arguments delta is added to.
+          item_id:,
+          # The index of the output item that the function-call arguments delta is added to.
+          output_index:,
+          # The sequence number of this event.
+          sequence_number:,
+          # The agent that owns this multi-agent streaming event.
+          agent: nil,
+          # The type of the event. Always `response.function_call_arguments.delta`.
+          type: :"response.function_call_arguments.delta"
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              delta: String,
+              item_id: String,
+              output_index: Integer,
+              sequence_number: Integer,
+              type: Symbol,
+              agent:
+                T.nilable(
+                  OpenAI::Beta::BetaResponseFunctionCallArgumentsDeltaEvent::Agent
+                )
+            }
+          )
+        end
+        def to_hash
+        end
+
+        class Agent < OpenAI::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                OpenAI::Beta::BetaResponseFunctionCallArgumentsDeltaEvent::Agent,
+                OpenAI::Internal::AnyHash
+              )
+            end
+
+          # The canonical name of the agent that produced this item.
+          sig { returns(String) }
+          attr_accessor :agent_name
+
+          # The agent that owns this multi-agent streaming event.
+          sig { params(agent_name: String).returns(T.attached_class) }
+          def self.new(
+            # The canonical name of the agent that produced this item.
+            agent_name:
+          )
+          end
+
+          sig { override.returns({ agent_name: String }) }
+          def to_hash
+          end
+        end
+      end
+    end
+  end
+end