openai 0.89.0 → 0.90.0

data/rbi/openai/models/beta/input_content.rbi

@@ -0,0 +1,124 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Beta
+
+      # User-provided content recorded in a session item.
+      module InputContent
+        extend OpenAI::Internal::Type::Union
+
+        Variants = T.type_alias do
+          T.any(
+            OpenAI::Beta::InputContent::InputText,
+            OpenAI::Beta::InputContent::InputImage
+          )
+        end
+
+        class InputText < OpenAI::Internal::Type::BaseModel
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::Beta::InputContent::InputText,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+          # The text supplied to the agent.
+          sig { returns(String) }
+          attr_accessor :text
+
+          # The type of the object. Always `input_text`.
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          # Text input recorded in a session item.
+          sig do
+            params(
+
+              text: String,
+
+              type: Symbol
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(
+
+            # The text supplied to the agent.
+            text:,
+
+            # The type of the object. Always `input_text`.
+
+            type: :input_text
+          )
+          end
+
+          sig do
+            override.returns(
+              {text: String, type: Symbol}
+            )
+          end
+          def to_hash
+          end
+
+        end
+
+        class InputImage < OpenAI::Internal::Type::BaseModel
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::Beta::InputContent::InputImage,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+          # The URL of the image supplied to the agent, which may be a base64-encoded data
+          # URL.
+          sig { returns(String) }
+          attr_accessor :image_url
+
+          # The type of the object. Always `input_image`.
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          # Image input recorded in a session item.
+          sig do
+            params(
+
+              image_url: String,
+
+              type: Symbol
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(
+
+            # The URL of the image supplied to the agent, which may be a base64-encoded data
+            # URL.
+            image_url:,
+
+            # The type of the object. Always `input_image`.
+
+            type: :input_image
+          )
+          end
+
+          sig do
+            override.returns(
+              {image_url: String, type: Symbol}
+            )
+          end
+          def to_hash
+          end
+
+        end
+
+        sig { override.returns(T::Array[OpenAI::Beta::InputContent::Variants]) }
+        def self.variants
+        end
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/beta/input_content_param.rbi

@@ -0,0 +1,122 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Beta
+
+      # Content included in an input message.
+      module InputContentParam
+        extend OpenAI::Internal::Type::Union
+
+        Variants = T.type_alias do
+          T.any(
+            OpenAI::Beta::InputContentParam::InputText,
+            OpenAI::Beta::InputContentParam::InputImage
+          )
+        end
+
+        class InputText < OpenAI::Internal::Type::BaseModel
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::Beta::InputContentParam::InputText,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+          # The text sent to the model.
+          sig { returns(String) }
+          attr_accessor :text
+
+          # The type of the object. Always `input_text`.
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          # Text input to the model.
+          sig do
+            params(
+
+              text: String,
+
+              type: Symbol
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(
+
+            # The text sent to the model.
+            text:,
+
+            # The type of the object. Always `input_text`.
+
+            type: :input_text
+          )
+          end
+
+          sig do
+            override.returns(
+              {text: String, type: Symbol}
+            )
+          end
+          def to_hash
+          end
+
+        end
+
+        class InputImage < OpenAI::Internal::Type::BaseModel
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::Beta::InputContentParam::InputImage,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+          # The URL of the image sent to the model.
+          sig { returns(String) }
+          attr_accessor :image_url
+
+          # The type of the object. Always `input_image`.
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          # Image input to the model.
+          sig do
+            params(
+
+              image_url: String,
+
+              type: Symbol
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(
+
+            # The URL of the image sent to the model.
+            image_url:,
+
+            # The type of the object. Always `input_image`.
+
+            type: :input_image
+          )
+          end
+
+          sig do
+            override.returns(
+              {image_url: String, type: Symbol}
+            )
+          end
+          def to_hash
+          end
+
+        end
+
+        sig { override.returns(T::Array[OpenAI::Beta::InputContentParam::Variants]) }
+        def self.variants
+        end
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/beta/mcp_transport.rbi

@@ -0,0 +1,149 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Beta
+
+      # The transport used to connect to an MCP server.
+      module McpTransport
+        extend OpenAI::Internal::Type::Union
+
+        Variants = T.type_alias do
+          T.any(
+            OpenAI::Beta::McpTransport::HTTP,
+            OpenAI::Beta::McpTransport::Stdio
+          )
+        end
+
+        class HTTP < OpenAI::Internal::Type::BaseModel
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::Beta::McpTransport::HTTP,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+          # The URL of the MCP server.
+          sig { returns(String) }
+          attr_accessor :server_url
+
+          # The type of the object. Always `http`.
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          # Connects to an MCP server over HTTP.
+          sig do
+            params(
+
+              server_url: String,
+
+              type: Symbol
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(
+
+            # The URL of the MCP server.
+            server_url:,
+
+            # The type of the object. Always `http`.
+
+            type: :http
+          )
+          end
+
+          sig do
+            override.returns(
+              {server_url: String, type: Symbol}
+            )
+          end
+          def to_hash
+          end
+
+        end
+
+        class Stdio < OpenAI::Internal::Type::BaseModel
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::Beta::McpTransport::Stdio,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+          # Arguments passed to the MCP server command.
+          sig { returns(T::Array[String]) }
+          attr_accessor :args
+
+          # The command used to start the MCP server.
+          sig { returns(String) }
+          attr_accessor :command
+
+          # The working directory used to start the MCP server.
+          sig { returns(String) }
+          attr_accessor :cwd
+
+          # Environment variable names inherited from the execution environment.
+          sig { returns(T::Array[String]) }
+          attr_accessor :env_vars
+
+          # The type of the object. Always `stdio`.
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          # Starts an MCP server as a local process.
+          sig do
+            params(
+
+              args: T::Array[String],
+
+              command: String,
+
+              cwd: String,
+
+              env_vars: T::Array[String],
+
+              type: Symbol
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(
+
+            # Arguments passed to the MCP server command.
+            args:,
+
+            # The command used to start the MCP server.
+            command:,
+
+            # The working directory used to start the MCP server.
+            cwd:,
+
+            # Environment variable names inherited from the execution environment.
+            env_vars:,
+
+            # The type of the object. Always `stdio`.
+
+            type: :stdio
+          )
+          end
+
+          sig do
+            override.returns(
+              {args: T::Array[String], command: String, cwd: String, env_vars: T::Array[String], type: Symbol}
+            )
+          end
+          def to_hash
+          end
+
+        end
+
+        sig { override.returns(T::Array[OpenAI::Beta::McpTransport::Variants]) }
+        def self.variants
+        end
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/beta/mcp_transport_param.rbi

@@ -0,0 +1,188 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Beta
+
+      # The transport used to connect to an MCP server.
+      module McpTransportParam
+        extend OpenAI::Internal::Type::Union
+
+        Variants = T.type_alias do
+          T.any(
+            OpenAI::Beta::McpTransportParam::HTTP,
+            OpenAI::Beta::McpTransportParam::Stdio
+          )
+        end
+
+        class HTTP < OpenAI::Internal::Type::BaseModel
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::Beta::McpTransportParam::HTTP,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+          # The URL of the MCP server.
+          sig { returns(String) }
+          attr_accessor :server_url
+
+          # The type of the object. Always `http`.
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          # The authorization value sent to the MCP server, if any.
+          sig { returns(T.nilable(String)) }
+          attr_accessor :authorization
+
+          # Additional HTTP headers sent to the MCP server.
+          sig { returns(T.nilable(T::Hash[Symbol, String])) }
+          attr_accessor :headers
+
+          # Connects to an MCP server over HTTP.
+          sig do
+            params(
+
+              server_url: String,
+
+              authorization: T.nilable(String),
+
+              headers: T.nilable(T::Hash[Symbol, String]),
+
+              type: Symbol
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(
+
+            # The URL of the MCP server.
+            server_url:,
+
+            # The authorization value sent to the MCP server, if any.
+            authorization: nil,
+
+            # Additional HTTP headers sent to the MCP server.
+            headers: nil,
+
+            # The type of the object. Always `http`.
+
+            type: :http
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                server_url: String,
+                type: Symbol,
+                authorization: T.nilable(String),
+                headers: T.nilable(T::Hash[Symbol, String])
+              }
+            )
+          end
+          def to_hash
+          end
+
+        end
+
+        class Stdio < OpenAI::Internal::Type::BaseModel
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::Beta::McpTransportParam::Stdio,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+          # The command used to start the MCP server.
+          sig { returns(String) }
+          attr_accessor :command
+
+          # The working directory used to start the MCP server.
+          sig { returns(String) }
+          attr_accessor :cwd
+
+          # The type of the object. Always `stdio`.
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          # Arguments passed to the MCP server command.
+          sig { returns(T.nilable(T::Array[String])) }
+          attr_accessor :args
+
+          # Environment variables set for the MCP server process.
+          sig { returns(T.nilable(T::Hash[Symbol, String])) }
+          attr_accessor :env
+
+          # Environment variable names to inherit from the selected execution environment.
+          sig { returns(T.nilable(T::Array[String])) }
+          attr_accessor :env_vars
+
+          # Starts an MCP server as a local process.
+          sig do
+            params(
+
+              command: String,
+
+              cwd: String,
+
+              args: T.nilable(T::Array[String]),
+
+              env: T.nilable(T::Hash[Symbol, String]),
+
+              env_vars: T.nilable(T::Array[String]),
+
+              type: Symbol
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(
+
+            # The command used to start the MCP server.
+            command:,
+
+            # The working directory used to start the MCP server.
+            cwd:,
+
+            # Arguments passed to the MCP server command.
+            args: nil,
+
+            # Environment variables set for the MCP server process.
+            env: nil,
+
+            # Environment variable names to inherit from the selected execution environment.
+            env_vars: nil,
+
+            # The type of the object. Always `stdio`.
+
+            type: :stdio
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                command: String,
+                cwd: String,
+                type: Symbol,
+                args: T.nilable(T::Array[String]),
+                env: T.nilable(T::Hash[Symbol, String]),
+                env_vars: T.nilable(T::Array[String])
+              }
+            )
+          end
+          def to_hash
+          end
+
+        end
+
+        sig { override.returns(T::Array[OpenAI::Beta::McpTransportParam::Variants]) }
+        def self.variants
+        end
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/beta/multi_agent_config.rbi

@@ -0,0 +1,61 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Beta
+
+      class MultiAgentConfig < OpenAI::Internal::Type::BaseModel
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Beta::MultiAgentConfig,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        # Whether subagent tools are enabled. Defaults to false.
+        sig { returns(T::Boolean) }
+        attr_accessor :enabled
+
+        # Maximum number of subagents that may run concurrently, or null when disabled.
+        # Defaults to 6 when enabled.
+        sig { returns(T.nilable(Integer)) }
+        attr_accessor :max_concurrent_subagents
+
+        # The resolved configuration for creating and coordinating subagents.
+        sig do
+          params(
+
+            enabled: T::Boolean,
+
+            max_concurrent_subagents: T.nilable(Integer)
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          # Whether subagent tools are enabled. Defaults to false.
+          enabled:,
+
+          # Maximum number of subagents that may run concurrently, or null when disabled.
+          # Defaults to 6 when enabled.
+
+          max_concurrent_subagents:
+        )
+        end
+
+        sig do
+          override.returns(
+            {enabled: T::Boolean, max_concurrent_subagents: T.nilable(Integer)}
+          )
+        end
+        def to_hash
+        end
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/beta/multi_agent_config_param.rbi

@@ -0,0 +1,62 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Beta
+
+      class MultiAgentConfigParam < OpenAI::Internal::Type::BaseModel
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Beta::MultiAgentConfigParam,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        # Whether subagent tools are enabled.
+        sig { returns(T::Boolean) }
+        attr_accessor :enabled
+
+        # Maximum number of subagents that may run concurrently. Defaults to 6.
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :max_concurrent_subagents
+
+        sig { params(max_concurrent_subagents: Integer).void }
+        attr_writer :max_concurrent_subagents
+
+        # Explicit configuration for creating and coordinating subagents.
+        sig do
+          params(
+
+            enabled: T::Boolean,
+
+            max_concurrent_subagents: Integer
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          # Whether subagent tools are enabled.
+          enabled:,
+
+          # Maximum number of subagents that may run concurrently. Defaults to 6.
+
+          max_concurrent_subagents: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {enabled: T::Boolean, max_concurrent_subagents: Integer}
+          )
+        end
+        def to_hash
+        end
+
+      end
+
+    end
+
+  end
+end