openai 0.89.0 → 0.90.0

data/rbi/openai/models/beta/text_format.rbi

@@ -0,0 +1,113 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Beta
+
+      # The effective output format for generated text.
+      module TextFormat
+        extend OpenAI::Internal::Type::Union
+
+        Variants = T.type_alias do
+          T.any(
+            OpenAI::Beta::TextFormat::Text,
+            OpenAI::Beta::TextFormat::JSONSchema
+          )
+        end
+
+        class Text < OpenAI::Internal::Type::BaseModel
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::Beta::TextFormat::Text,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+          # The type of the object. Always `text`.
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          # Generates ordinary text without a structured-output constraint.
+          sig do
+            params(
+
+              type: Symbol
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(
+
+            # The type of the object. Always `text`.
+
+            type: :text
+          )
+          end
+
+          sig do
+            override.returns(
+              {type: Symbol}
+            )
+          end
+          def to_hash
+          end
+
+        end
+
+        class JSONSchema < OpenAI::Internal::Type::BaseModel
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::Beta::TextFormat::JSONSchema,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+          # The JSON Schema that generated text must match.
+          sig { returns(T::Hash[Symbol, T.anything]) }
+          attr_accessor :schema
+
+          # The type of the object. Always `json_schema`.
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          # Constrains generated text to a JSON Schema.
+          sig do
+            params(
+
+              schema: T::Hash[Symbol, T.anything],
+
+              type: Symbol
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(
+
+            # The JSON Schema that generated text must match.
+            schema:,
+
+            # The type of the object. Always `json_schema`.
+
+            type: :json_schema
+          )
+          end
+
+          sig do
+            override.returns(
+              {schema: T::Hash[Symbol, T.anything], type: Symbol}
+            )
+          end
+          def to_hash
+          end
+
+        end
+
+        sig { override.returns(T::Array[OpenAI::Beta::TextFormat::Variants]) }
+        def self.variants
+        end
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/beta/text_format_param.rbi

@@ -0,0 +1,113 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Beta
+
+      # The output format for generated text.
+      module TextFormatParam
+        extend OpenAI::Internal::Type::Union
+
+        Variants = T.type_alias do
+          T.any(
+            OpenAI::Beta::TextFormatParam::Text,
+            OpenAI::Beta::TextFormatParam::JSONSchema
+          )
+        end
+
+        class Text < OpenAI::Internal::Type::BaseModel
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::Beta::TextFormatParam::Text,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+          # The type of the object. Always `text`.
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          # Generates ordinary text without a structured-output constraint.
+          sig do
+            params(
+
+              type: Symbol
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(
+
+            # The type of the object. Always `text`.
+
+            type: :text
+          )
+          end
+
+          sig do
+            override.returns(
+              {type: Symbol}
+            )
+          end
+          def to_hash
+          end
+
+        end
+
+        class JSONSchema < OpenAI::Internal::Type::BaseModel
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::Beta::TextFormatParam::JSONSchema,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+          # The JSON Schema that generated text must match.
+          sig { returns(T::Hash[Symbol, T.anything]) }
+          attr_accessor :schema
+
+          # The type of the object. Always `json_schema`.
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          # Constrains generated text to a JSON Schema.
+          sig do
+            params(
+
+              schema: T::Hash[Symbol, T.anything],
+
+              type: Symbol
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(
+
+            # The JSON Schema that generated text must match.
+            schema:,
+
+            # The type of the object. Always `json_schema`.
+
+            type: :json_schema
+          )
+          end
+
+          sig do
+            override.returns(
+              {schema: T::Hash[Symbol, T.anything], type: Symbol}
+            )
+          end
+          def to_hash
+          end
+
+        end
+
+        sig { override.returns(T::Array[OpenAI::Beta::TextFormatParam::Variants]) }
+        def self.variants
+        end
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/beta/token_usage.rbi

@@ -0,0 +1,174 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Beta
+
+      class TokenUsage < OpenAI::Internal::Type::BaseModel
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Beta::TokenUsage,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        # The number of input tokens used by the agent.
+        sig { returns(Integer) }
+        attr_accessor :input_tokens
+
+        # A breakdown of the agent's input token usage.
+        sig { returns(OpenAI::Beta::TokenUsage::InputTokensDetails) }
+        attr_reader :input_tokens_details
+
+        sig { params(input_tokens_details: OpenAI::Beta::TokenUsage::InputTokensDetails::OrHash).void }
+        attr_writer :input_tokens_details
+
+        # The number of output tokens generated by the agent.
+        sig { returns(Integer) }
+        attr_accessor :output_tokens
+
+        # A breakdown of the agent's output token usage.
+        sig { returns(OpenAI::Beta::TokenUsage::OutputTokensDetails) }
+        attr_reader :output_tokens_details
+
+        sig { params(output_tokens_details: OpenAI::Beta::TokenUsage::OutputTokensDetails::OrHash).void }
+        attr_writer :output_tokens_details
+
+        # The total number of input and output tokens used by the agent.
+        sig { returns(Integer) }
+        attr_accessor :total_tokens
+
+        # Recorded token usage for a session or turn. Usage is best effort and may change.
+        sig do
+          params(
+
+            input_tokens: Integer,
+
+            input_tokens_details: OpenAI::Beta::TokenUsage::InputTokensDetails::OrHash,
+
+            output_tokens: Integer,
+
+            output_tokens_details: OpenAI::Beta::TokenUsage::OutputTokensDetails::OrHash,
+
+            total_tokens: Integer
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          # The number of input tokens used by the agent.
+          input_tokens:,
+
+          # A breakdown of the agent's input token usage.
+          input_tokens_details:,
+
+          # The number of output tokens generated by the agent.
+          output_tokens:,
+
+          # A breakdown of the agent's output token usage.
+          output_tokens_details:,
+
+          # The total number of input and output tokens used by the agent.
+
+          total_tokens:
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              input_tokens: Integer,
+              input_tokens_details: OpenAI::Beta::TokenUsage::InputTokensDetails,
+              output_tokens: Integer,
+              output_tokens_details: OpenAI::Beta::TokenUsage::OutputTokensDetails,
+              total_tokens: Integer
+            }
+          )
+        end
+        def to_hash
+        end
+
+        class InputTokensDetails < OpenAI::Internal::Type::BaseModel
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::Beta::TokenUsage::InputTokensDetails,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+          # The number of input tokens retrieved from the prompt cache.
+          sig { returns(Integer) }
+          attr_accessor :cached_tokens
+
+          # A breakdown of the agent's input token usage.
+          sig do
+            params(
+
+              cached_tokens: Integer
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(
+
+            # The number of input tokens retrieved from the prompt cache.
+
+            cached_tokens:
+          )
+          end
+
+          sig do
+            override.returns(
+              {cached_tokens: Integer}
+            )
+          end
+          def to_hash
+          end
+
+        end
+
+        class OutputTokensDetails < OpenAI::Internal::Type::BaseModel
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::Beta::TokenUsage::OutputTokensDetails,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+          # The number of output tokens used for reasoning.
+          sig { returns(Integer) }
+          attr_accessor :reasoning_tokens
+
+          # A breakdown of the agent's output token usage.
+          sig do
+            params(
+
+              reasoning_tokens: Integer
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(
+
+            # The number of output tokens used for reasoning.
+
+            reasoning_tokens:
+          )
+          end
+
+          sig do
+            override.returns(
+              {reasoning_tokens: Integer}
+            )
+          end
+          def to_hash
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/beta/web_search_action.rbi

@@ -0,0 +1,227 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Beta
+
+      # An action performed by the web search tool.
+      module WebSearchAction
+        extend OpenAI::Internal::Type::Union
+
+        Variants = T.type_alias do
+          T.any(
+            OpenAI::Beta::WebSearchAction::Search,
+            OpenAI::Beta::WebSearchAction::OpenPage,
+            OpenAI::Beta::WebSearchAction::FindInPage,
+            OpenAI::Beta::WebSearchAction::Other
+          )
+        end
+
+        class Search < OpenAI::Internal::Type::BaseModel
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::Beta::WebSearchAction::Search,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+          # The search queries, when multiple queries were used.
+          sig { returns(T.nilable(T::Array[String])) }
+          attr_accessor :queries
+
+          # The search query, when a single query was used.
+          sig { returns(T.nilable(String)) }
+          attr_accessor :query
+
+          # The type of the object. Always `search`.
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          # A search query or group of search queries.
+          sig do
+            params(
+
+              queries: T.nilable(T::Array[String]),
+
+              query: T.nilable(String),
+
+              type: Symbol
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(
+
+            # The search queries, when multiple queries were used.
+            queries:,
+
+            # The search query, when a single query was used.
+            query:,
+
+            # The type of the object. Always `search`.
+
+            type: :search
+          )
+          end
+
+          sig do
+            override.returns(
+              {queries: T.nilable(T::Array[String]), query: T.nilable(String), type: Symbol}
+            )
+          end
+          def to_hash
+          end
+
+        end
+
+        class OpenPage < OpenAI::Internal::Type::BaseModel
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::Beta::WebSearchAction::OpenPage,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+          # The type of the object. Always `open_page`.
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          # The URL of the page that was opened.
+          sig { returns(T.nilable(String)) }
+          attr_accessor :url
+
+          # Opens a web page.
+          sig do
+            params(
+
+              url: T.nilable(String),
+
+              type: Symbol
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(
+
+            # The URL of the page that was opened.
+            url:,
+
+            # The type of the object. Always `open_page`.
+
+            type: :open_page
+          )
+          end
+
+          sig do
+            override.returns(
+              {type: Symbol, url: T.nilable(String)}
+            )
+          end
+          def to_hash
+          end
+
+        end
+
+        class FindInPage < OpenAI::Internal::Type::BaseModel
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::Beta::WebSearchAction::FindInPage,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+          # The text pattern that was searched for.
+          sig { returns(T.nilable(String)) }
+          attr_accessor :pattern
+
+          # The type of the object. Always `find_in_page`.
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          # The URL of the page that was searched.
+          sig { returns(T.nilable(String)) }
+          attr_accessor :url
+
+          # Finds text within a web page.
+          sig do
+            params(
+
+              pattern: T.nilable(String),
+
+              url: T.nilable(String),
+
+              type: Symbol
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(
+
+            # The text pattern that was searched for.
+            pattern:,
+
+            # The URL of the page that was searched.
+            url:,
+
+            # The type of the object. Always `find_in_page`.
+
+            type: :find_in_page
+          )
+          end
+
+          sig do
+            override.returns(
+              {pattern: T.nilable(String), type: Symbol, url: T.nilable(String)}
+            )
+          end
+          def to_hash
+          end
+
+        end
+
+        class Other < OpenAI::Internal::Type::BaseModel
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::Beta::WebSearchAction::Other,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+          # The type of the object. Always `other`.
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          # Another web search action.
+          sig do
+            params(
+
+              type: Symbol
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(
+
+            # The type of the object. Always `other`.
+
+            type: :other
+          )
+          end
+
+          sig do
+            override.returns(
+              {type: Symbol}
+            )
+          end
+          def to_hash
+          end
+
+        end
+
+        sig { override.returns(T::Array[OpenAI::Beta::WebSearchAction::Variants]) }
+        def self.variants
+        end
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/resources/beta/agents/environments/files.rbi

@@ -0,0 +1,79 @@
+# typed: strong
+
+module OpenAI
+  module Resources
+
+    class Beta
+
+      class Agents
+
+        class Environments
+
+          class Files
+
+            # Copies inline bytes or a Files API file into a connected execution environment.
+            # See
+            # [environment files](https://developers.openai.com/api/docs/guides/agents-api/environments/files).
+            sig {
+              params(
+                environment_id: String,
+                hosted_environment_file_param: T.any(
+                  OpenAI::Beta::HostedEnvironmentFileParam::FileID::OrHash,
+                  OpenAI::Beta::HostedEnvironmentFileParam::Inline::OrHash
+                ),
+                request_options: OpenAI::RequestOptions::OrHash
+              )
+                .returns(OpenAI::Beta::Agents::Environments::EnvironmentFile)
+            }
+            def create(
+              # The ID of the environment.
+              environment_id,
+              # A file materialized in an OpenAI-hosted execution environment.
+              hosted_environment_file_param:,
+              request_options: {}
+            )
+            end
+
+            # Lists live files on a connected execution environment with optional directory
+            # filtering and opaque cursor pagination. See
+            # [environment files](https://developers.openai.com/api/docs/guides/agents-api/environments/files).
+            sig {
+              params(
+                environment_id: String,
+                limit: T.nilable(Integer),
+                order: OpenAI::Beta::Agents::Environments::FileListParams::Order::OrSymbol,
+                page: String,
+                path: T.nilable(String),
+                request_options: OpenAI::RequestOptions::OrHash
+              )
+                .returns(OpenAI::Internal::TokenPage[OpenAI::Beta::Agents::Environments::EnvironmentFile])
+            }
+            def list(
+              # The ID of the environment.
+              environment_id,
+              # The maximum number of files to return, between 1 and 100.
+              limit: nil,
+              # Sort by case-sensitive path components. Defaults to descending.
+              order: nil,
+              # The opaque token from the previous page. Keep the same path, order, and limit.
+              page: nil,
+              # Restrict the listing to this absolute workspace directory.
+              path: nil,
+              request_options: {}
+            )
+            end
+
+            # @api private
+            sig { params(client: OpenAI::Client).returns(T.attached_class) }
+            def self.new(client:)
+            end
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+end