openai 0.89.0 → 0.90.0

data/rbi/openai/models/beta/persisted_mcp_transport_param.rbi

@@ -0,0 +1,164 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Beta
+
+      # A credential-free transport used to connect to an MCP server.
+      module PersistedMcpTransportParam
+        extend OpenAI::Internal::Type::Union
+
+        Variants = T.type_alias do
+          T.any(
+            OpenAI::Beta::PersistedMcpTransportParam::HTTP,
+            OpenAI::Beta::PersistedMcpTransportParam::Stdio
+          )
+        end
+
+        class HTTP < OpenAI::Internal::Type::BaseModel
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::Beta::PersistedMcpTransportParam::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
+
+          # Non-secret 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,
+
+              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:,
+
+            # Non-secret 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, 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::PersistedMcpTransportParam::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 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_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 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_vars: T.nilable(T::Array[String])
+              }
+            )
+          end
+          def to_hash
+          end
+
+        end
+
+        sig { override.returns(T::Array[OpenAI::Beta::PersistedMcpTransportParam::Variants]) }
+        def self.variants
+        end
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/beta/session_error.rbi

@@ -0,0 +1,77 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Beta
+
+      class SessionError < OpenAI::Internal::Type::BaseModel
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Beta::SessionError,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        # The machine-readable error code, if any.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :code
+
+        # A customer-safe explanation of the error.
+        sig { returns(String) }
+        attr_accessor :message
+
+        # The request parameter associated with the error, if any.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :param
+
+        # The error type.
+        sig { returns(String) }
+        attr_accessor :type
+
+        # An error payload with the same public fields as Responses API streaming errors.
+        sig do
+          params(
+
+            code: T.nilable(String),
+
+            message: String,
+
+            param: T.nilable(String),
+
+            type: String
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          # The machine-readable error code, if any.
+          code:,
+
+          # A customer-safe explanation of the error.
+          message:,
+
+          # The request parameter associated with the error, if any.
+          param:,
+
+          # The error type.
+
+          type:
+        )
+        end
+
+        sig do
+          override.returns(
+            {code: T.nilable(String), message: String, param: T.nilable(String), type: String}
+          )
+        end
+        def to_hash
+        end
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/beta/session_turn_error.rbi

@@ -0,0 +1,125 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Beta
+
+      class SessionTurnError < OpenAI::Internal::Type::BaseModel
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Beta::SessionTurnError,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        # A stable, machine-readable failure category.
+        sig { returns(OpenAI::Beta::SessionTurnError::Code::TaggedSymbol) }
+        attr_accessor :code
+
+        # A customer-safe explanation of the failure.
+        sig { returns(String) }
+        attr_accessor :message
+
+        # A customer-safe error describing why a session request failed.
+        sig do
+          params(
+
+            code: OpenAI::Beta::SessionTurnError::Code::OrSymbol,
+
+            message: String
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          # A stable, machine-readable failure category.
+          code:,
+
+          # A customer-safe explanation of the failure.
+
+          message:
+        )
+        end
+
+        sig do
+          override.returns(
+            {code: OpenAI::Beta::SessionTurnError::Code::TaggedSymbol, message: String}
+          )
+        end
+        def to_hash
+        end
+
+        # A stable, machine-readable failure category.
+        module Code
+          extend OpenAI::Internal::Type::Enum
+
+          TaggedSymbol = T.type_alias { T.all(Symbol, OpenAI::Beta::SessionTurnError::Code) }
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          # The request exceeds the model's context window.
+          CONTEXT_LENGTH_EXCEEDED = T.let(:context_length_exceeded, OpenAI::Beta::SessionTurnError::Code::TaggedSymbol)
+
+          # The session has reached its usage budget.
+          SESSION_BUDGET_EXCEEDED = T.let(:session_budget_exceeded, OpenAI::Beta::SessionTurnError::Code::TaggedSymbol)
+
+          # The organization has reached a usage, plan, or billing limit.
+          USAGE_LIMIT_EXCEEDED = T.let(:usage_limit_exceeded, OpenAI::Beta::SessionTurnError::Code::TaggedSymbol)
+
+          # The request exceeds the available rate limit.
+          RATE_LIMIT_EXCEEDED = T.let(:rate_limit_exceeded, OpenAI::Beta::SessionTurnError::Code::TaggedSymbol)
+
+          # The model service is temporarily overloaded.
+          SERVER_OVERLOADED = T.let(:server_overloaded, OpenAI::Beta::SessionTurnError::Code::TaggedSymbol)
+
+          # The request was rejected by a safety policy.
+          CYBER_POLICY = T.let(:cyber_policy, OpenAI::Beta::SessionTurnError::Code::TaggedSymbol)
+
+          # The request could not connect to the model service.
+          CONNECTION_FAILED = T.let(:connection_failed, OpenAI::Beta::SessionTurnError::Code::TaggedSymbol)
+
+          # The model service encountered an unexpected error.
+          SERVER_ERROR = T.let(:server_error, OpenAI::Beta::SessionTurnError::Code::TaggedSymbol)
+
+          # The API credentials are invalid or lack the required access.
+          AUTHENTICATION_ERROR = T.let(:authentication_error, OpenAI::Beta::SessionTurnError::Code::TaggedSymbol)
+
+          # The request contains invalid input or configuration.
+          INVALID_REQUEST = T.let(:invalid_request, OpenAI::Beta::SessionTurnError::Code::TaggedSymbol)
+
+          # The requested model or resource is unavailable.
+          RESOURCE_NOT_FOUND = T.let(:resource_not_found, OpenAI::Beta::SessionTurnError::Code::TaggedSymbol)
+
+          # The request could not complete in its execution environment.
+          SANDBOX_ERROR = T.let(:sandbox_error, OpenAI::Beta::SessionTurnError::Code::TaggedSymbol)
+
+          # The executor must be upgraded before it can run this turn.
+          EXECUTOR_VERSION_INCOMPATIBLE = T.let(
+            :executor_version_incompatible,
+            OpenAI::Beta::SessionTurnError::Code::TaggedSymbol
+          )
+
+          # The session cannot accept additional input while a request is running.
+          ACTIVE_TURN_NOT_STEERABLE = T.let(
+            :active_turn_not_steerable,
+            OpenAI::Beta::SessionTurnError::Code::TaggedSymbol
+          )
+
+          # The request timed out before the model service responded.
+          REQUEST_TIMEOUT = T.let(:request_timeout, OpenAI::Beta::SessionTurnError::Code::TaggedSymbol)
+
+          # An unexpected internal error prevented the session request from completing.
+          INTERNAL_ERROR = T.let(:internal_error, OpenAI::Beta::SessionTurnError::Code::TaggedSymbol)
+
+          sig { override.returns(T::Array[OpenAI::Beta::SessionTurnError::Code::TaggedSymbol]) }
+          def self.values
+          end
+        end
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/beta/setup_command_param.rbi

@@ -0,0 +1,59 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Beta
+
+      class SetupCommandParam < OpenAI::Internal::Type::BaseModel
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Beta::SetupCommandParam,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        # The shell command to execute.
+        sig { returns(String) }
+        attr_accessor :command
+
+        # The absolute working directory. Defaults to `/workspace`.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :cwd
+
+        # A confidential setup command executed before the hosted agent starts.
+        sig do
+          params(
+
+            command: String,
+
+            cwd: T.nilable(String)
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          # The shell command to execute.
+          command:,
+
+          # The absolute working directory. Defaults to `/workspace`.
+
+          cwd: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {command: String, cwd: T.nilable(String)}
+          )
+        end
+        def to_hash
+        end
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/beta/subagent.rbi

@@ -0,0 +1,158 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Beta
+
+      class Subagent < OpenAI::Internal::Type::BaseModel
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Beta::Subagent,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        # The ID of the subagent.
+        sig { returns(String) }
+        attr_accessor :id
+
+        # The Unix timestamp, in seconds, when the subagent was closed. Null while active,
+        # including after resume.
+        sig { returns(T.nilable(Integer)) }
+        attr_accessor :closed_at
+
+        # Initial task content, or null when unavailable. Text may contain placeholders
+        # for images or audio when only a preview is available.
+        sig { returns(T.nilable(T::Array[OpenAI::Beta::AgentContent::Variants])) }
+        attr_accessor :instructions
+
+        # The runner-assigned nickname, or null when unavailable.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :name
+
+        # The object type. Always `agent.session.subagent`.
+        sig { returns(Symbol) }
+        attr_accessor :object
+
+        # The Unix timestamp, in seconds, when the subagent was first opened. Resuming
+        # does not change it.
+        sig { returns(Integer) }
+        attr_accessor :opened_at
+
+        # The ID of the agent that created this subagent.
+        sig { returns(String) }
+        attr_accessor :parent_agent_id
+
+        # The ID of the session that owns the subagent.
+        sig { returns(String) }
+        attr_accessor :session_id
+
+        # The current status of the subagent.
+        sig { returns(OpenAI::Beta::Subagent::Status::TaggedSymbol) }
+        attr_accessor :status
+
+        # A subagent created within a session.
+        sig do
+          params(
+
+            id: String,
+
+            closed_at: T.nilable(Integer),
+
+            instructions: T.nilable(
+              T::Array[T.any(OpenAI::Beta::OutputText::OrHash, OpenAI::Beta::AgentContent::EncryptedContent::OrHash)]
+            ),
+
+            name: T.nilable(String),
+
+            opened_at: Integer,
+
+            parent_agent_id: String,
+
+            session_id: String,
+
+            status: OpenAI::Beta::Subagent::Status::OrSymbol,
+
+            object: Symbol
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          # The ID of the subagent.
+          id:,
+
+          # The Unix timestamp, in seconds, when the subagent was closed. Null while active,
+          # including after resume.
+          closed_at:,
+
+          # Initial task content, or null when unavailable. Text may contain placeholders
+          # for images or audio when only a preview is available.
+          instructions:,
+
+          # The runner-assigned nickname, or null when unavailable.
+          name:,
+
+          # The Unix timestamp, in seconds, when the subagent was first opened. Resuming
+          # does not change it.
+          opened_at:,
+
+          # The ID of the agent that created this subagent.
+          parent_agent_id:,
+
+          # The ID of the session that owns the subagent.
+          session_id:,
+
+          # The current status of the subagent.
+          status:,
+
+          # The object type. Always `agent.session.subagent`.
+
+          object: :"agent.session.subagent"
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              id: String,
+              closed_at: T.nilable(Integer),
+              instructions: T.nilable(T::Array[OpenAI::Beta::AgentContent::Variants]),
+              name: T.nilable(String),
+              object: Symbol,
+              opened_at: Integer,
+              parent_agent_id: String,
+              session_id: String,
+              status: OpenAI::Beta::Subagent::Status::TaggedSymbol
+            }
+          )
+        end
+        def to_hash
+        end
+
+        # The current status of the subagent.
+        module Status
+          extend OpenAI::Internal::Type::Enum
+
+          TaggedSymbol = T.type_alias { T.all(Symbol, OpenAI::Beta::Subagent::Status) }
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          # The subagent remains available, including while idle between turns.
+          ACTIVE = T.let(:active, OpenAI::Beta::Subagent::Status::TaggedSymbol)
+
+          # The subagent is closed.
+          CLOSED = T.let(:closed, OpenAI::Beta::Subagent::Status::TaggedSymbol)
+
+          sig { override.returns(T::Array[OpenAI::Beta::Subagent::Status::TaggedSymbol]) }
+          def self.values
+          end
+        end
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/beta/summary_text.rbi

@@ -0,0 +1,59 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Beta
+
+      class SummaryText < OpenAI::Internal::Type::BaseModel
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Beta::SummaryText,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        # The reasoning summary text.
+        sig { returns(String) }
+        attr_accessor :text
+
+        # The content type. Always `summary_text`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # A reasoning summary content part.
+        sig do
+          params(
+
+            text: String,
+
+            type: Symbol
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          # The reasoning summary text.
+          text:,
+
+          # The content type. Always `summary_text`.
+
+          type: :summary_text
+        )
+        end
+
+        sig do
+          override.returns(
+            {text: String, type: Symbol}
+          )
+        end
+        def to_hash
+        end
+
+      end
+
+    end
+
+  end
+end