openai 0.89.0 → 0.90.0

data/rbi/openai/models/beta/agent_session_deleted.rbi

@@ -0,0 +1,71 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Beta
+
+      class AgentSessionDeleted < OpenAI::Internal::Type::BaseModel
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Beta::AgentSessionDeleted,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        # The ID of the deleted session.
+        sig { returns(String) }
+        attr_accessor :id
+
+        # Whether the session has been removed from the public API. Always `true`.
+        # Physical cleanup may still be in progress.
+        sig { returns(T::Boolean) }
+        attr_accessor :deleted
+
+        # The object type. Always `agent.session.deleted`.
+        sig { returns(Symbol) }
+        attr_accessor :object
+
+        # A Managed Agents session removed from the public API. Physical cleanup may
+        # continue asynchronously.
+        sig do
+          params(
+
+            id: String,
+
+            deleted: T::Boolean,
+
+            object: Symbol
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          # The ID of the deleted session.
+          id:,
+
+          # Whether the session has been removed from the public API. Always `true`.
+          # Physical cleanup may still be in progress.
+          deleted:,
+
+          # The object type. Always `agent.session.deleted`.
+
+          object: :"agent.session.deleted"
+        )
+        end
+
+        sig do
+          override.returns(
+            {id: String, deleted: T::Boolean, object: Symbol}
+          )
+        end
+        def to_hash
+        end
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/beta/agent_session_environment_connected_event.rbi

@@ -0,0 +1,95 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Beta
+
+      class AgentSessionEnvironmentConnectedEvent < OpenAI::Internal::Type::BaseModel
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Beta::AgentSessionEnvironmentConnectedEvent,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        # The current environment state.
+        sig { returns(OpenAI::Beta::AgentSessionEnvironmentState) }
+        attr_reader :environment
+
+        sig { params(environment: OpenAI::Beta::AgentSessionEnvironmentState::OrHash).void }
+        attr_writer :environment
+
+        # The unique ID of the event.
+        sig { returns(String) }
+        attr_accessor :event_id
+
+        # The ID of the session associated with the event.
+        sig { returns(String) }
+        attr_accessor :session_id
+
+        # The ID of the turn associated with the event, when applicable.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :turn_id
+
+        # The type of the object. Always `agent.session.environment.connected`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # Emitted when a session environment connects.
+        sig do
+          params(
+
+            environment: OpenAI::Beta::AgentSessionEnvironmentState::OrHash,
+
+            event_id: String,
+
+            session_id: String,
+
+            turn_id: T.nilable(String),
+
+            type: Symbol
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          # The current environment state.
+          environment:,
+
+          # The unique ID of the event.
+          event_id:,
+
+          # The ID of the session associated with the event.
+          session_id:,
+
+          # The ID of the turn associated with the event, when applicable.
+          turn_id:,
+
+          # The type of the object. Always `agent.session.environment.connected`.
+
+          type: :"agent.session.environment.connected"
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              environment: OpenAI::Beta::AgentSessionEnvironmentState,
+              event_id: String,
+              session_id: String,
+              turn_id: T.nilable(String),
+              type: Symbol
+            }
+          )
+        end
+        def to_hash
+        end
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/beta/agent_session_environment_disconnected_event.rbi

@@ -0,0 +1,95 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Beta
+
+      class AgentSessionEnvironmentDisconnectedEvent < OpenAI::Internal::Type::BaseModel
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Beta::AgentSessionEnvironmentDisconnectedEvent,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        # The current environment state.
+        sig { returns(OpenAI::Beta::AgentSessionEnvironmentState) }
+        attr_reader :environment
+
+        sig { params(environment: OpenAI::Beta::AgentSessionEnvironmentState::OrHash).void }
+        attr_writer :environment
+
+        # The unique ID of the event.
+        sig { returns(String) }
+        attr_accessor :event_id
+
+        # The ID of the session associated with the event.
+        sig { returns(String) }
+        attr_accessor :session_id
+
+        # The ID of the turn associated with the event, when applicable.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :turn_id
+
+        # The type of the object. Always `agent.session.environment.disconnected`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # Emitted when a session environment disconnects.
+        sig do
+          params(
+
+            environment: OpenAI::Beta::AgentSessionEnvironmentState::OrHash,
+
+            event_id: String,
+
+            session_id: String,
+
+            turn_id: T.nilable(String),
+
+            type: Symbol
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          # The current environment state.
+          environment:,
+
+          # The unique ID of the event.
+          event_id:,
+
+          # The ID of the session associated with the event.
+          session_id:,
+
+          # The ID of the turn associated with the event, when applicable.
+          turn_id:,
+
+          # The type of the object. Always `agent.session.environment.disconnected`.
+
+          type: :"agent.session.environment.disconnected"
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              environment: OpenAI::Beta::AgentSessionEnvironmentState,
+              event_id: String,
+              session_id: String,
+              turn_id: T.nilable(String),
+              type: Symbol
+            }
+          )
+        end
+        def to_hash
+        end
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/beta/agent_session_environment_failed_event.rbi

@@ -0,0 +1,95 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Beta
+
+      class AgentSessionEnvironmentFailedEvent < OpenAI::Internal::Type::BaseModel
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Beta::AgentSessionEnvironmentFailedEvent,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        # The current environment state.
+        sig { returns(OpenAI::Beta::AgentSessionEnvironmentState) }
+        attr_reader :environment
+
+        sig { params(environment: OpenAI::Beta::AgentSessionEnvironmentState::OrHash).void }
+        attr_writer :environment
+
+        # The unique ID of the event.
+        sig { returns(String) }
+        attr_accessor :event_id
+
+        # The ID of the session associated with the event.
+        sig { returns(String) }
+        attr_accessor :session_id
+
+        # The ID of the turn associated with the event, when applicable.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :turn_id
+
+        # The type of the object. Always `agent.session.environment.failed`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # Emitted when a session environment fails.
+        sig do
+          params(
+
+            environment: OpenAI::Beta::AgentSessionEnvironmentState::OrHash,
+
+            event_id: String,
+
+            session_id: String,
+
+            turn_id: T.nilable(String),
+
+            type: Symbol
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          # The current environment state.
+          environment:,
+
+          # The unique ID of the event.
+          event_id:,
+
+          # The ID of the session associated with the event.
+          session_id:,
+
+          # The ID of the turn associated with the event, when applicable.
+          turn_id:,
+
+          # The type of the object. Always `agent.session.environment.failed`.
+
+          type: :"agent.session.environment.failed"
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              environment: OpenAI::Beta::AgentSessionEnvironmentState,
+              event_id: String,
+              session_id: String,
+              turn_id: T.nilable(String),
+              type: Symbol
+            }
+          )
+        end
+        def to_hash
+        end
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/beta/agent_session_environment_pending_event.rbi

@@ -0,0 +1,95 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Beta
+
+      class AgentSessionEnvironmentPendingEvent < OpenAI::Internal::Type::BaseModel
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Beta::AgentSessionEnvironmentPendingEvent,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        # The current environment state.
+        sig { returns(OpenAI::Beta::AgentSessionEnvironmentState) }
+        attr_reader :environment
+
+        sig { params(environment: OpenAI::Beta::AgentSessionEnvironmentState::OrHash).void }
+        attr_writer :environment
+
+        # The unique ID of the event.
+        sig { returns(String) }
+        attr_accessor :event_id
+
+        # The ID of the session associated with the event.
+        sig { returns(String) }
+        attr_accessor :session_id
+
+        # The ID of the turn associated with the event, when applicable.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :turn_id
+
+        # The type of the object. Always `agent.session.environment.pending`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # Emitted while a session environment is being prepared.
+        sig do
+          params(
+
+            environment: OpenAI::Beta::AgentSessionEnvironmentState::OrHash,
+
+            event_id: String,
+
+            session_id: String,
+
+            turn_id: T.nilable(String),
+
+            type: Symbol
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          # The current environment state.
+          environment:,
+
+          # The unique ID of the event.
+          event_id:,
+
+          # The ID of the session associated with the event.
+          session_id:,
+
+          # The ID of the turn associated with the event, when applicable.
+          turn_id:,
+
+          # The type of the object. Always `agent.session.environment.pending`.
+
+          type: :"agent.session.environment.pending"
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              environment: OpenAI::Beta::AgentSessionEnvironmentState,
+              event_id: String,
+              session_id: String,
+              turn_id: T.nilable(String),
+              type: Symbol
+            }
+          )
+        end
+        def to_hash
+        end
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/beta/agent_session_environment_ready_event.rbi

@@ -0,0 +1,95 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Beta
+
+      class AgentSessionEnvironmentReadyEvent < OpenAI::Internal::Type::BaseModel
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Beta::AgentSessionEnvironmentReadyEvent,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        # The current environment state.
+        sig { returns(OpenAI::Beta::AgentSessionEnvironmentState) }
+        attr_reader :environment
+
+        sig { params(environment: OpenAI::Beta::AgentSessionEnvironmentState::OrHash).void }
+        attr_writer :environment
+
+        # The unique ID of the event.
+        sig { returns(String) }
+        attr_accessor :event_id
+
+        # The ID of the session associated with the event.
+        sig { returns(String) }
+        attr_accessor :session_id
+
+        # The ID of the turn associated with the event, when applicable.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :turn_id
+
+        # The type of the object. Always `agent.session.environment.ready`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # Emitted when a hosted session environment is ready to connect.
+        sig do
+          params(
+
+            environment: OpenAI::Beta::AgentSessionEnvironmentState::OrHash,
+
+            event_id: String,
+
+            session_id: String,
+
+            turn_id: T.nilable(String),
+
+            type: Symbol
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          # The current environment state.
+          environment:,
+
+          # The unique ID of the event.
+          event_id:,
+
+          # The ID of the session associated with the event.
+          session_id:,
+
+          # The ID of the turn associated with the event, when applicable.
+          turn_id:,
+
+          # The type of the object. Always `agent.session.environment.ready`.
+
+          type: :"agent.session.environment.ready"
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              environment: OpenAI::Beta::AgentSessionEnvironmentState,
+              event_id: String,
+              session_id: String,
+              turn_id: T.nilable(String),
+              type: Symbol
+            }
+          )
+        end
+        def to_hash
+        end
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/beta/agent_session_environment_state.rbi

@@ -0,0 +1,168 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Beta
+
+      class AgentSessionEnvironmentState < OpenAI::Internal::Type::BaseModel
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Beta::AgentSessionEnvironmentState,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        # The public ID of the environment.
+        sig { returns(String) }
+        attr_accessor :id
+
+        # An error reported while preparing a session environment.
+        sig { returns(T.nilable(OpenAI::Beta::AgentSessionEnvironmentState::Error)) }
+        attr_reader :error
+
+        sig { params(error: T.nilable(OpenAI::Beta::AgentSessionEnvironmentState::Error::OrHash)).void }
+        attr_writer :error
+
+        # The environment's connection status.
+        sig { returns(OpenAI::Beta::AgentSessionEnvironmentState::Status::TaggedSymbol) }
+        attr_accessor :status
+
+        # The environment type.
+        sig { returns(String) }
+        attr_accessor :type
+
+        # The current state of a session environment.
+        sig do
+          params(
+
+            id: String,
+
+            error: T.nilable(OpenAI::Beta::AgentSessionEnvironmentState::Error::OrHash),
+
+            status: OpenAI::Beta::AgentSessionEnvironmentState::Status::OrSymbol,
+
+            type: String
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          # The public ID of the environment.
+          id:,
+
+          # An error reported while preparing a session environment.
+          error:,
+
+          # The environment's connection status.
+          status:,
+
+          # The environment type.
+
+          type:
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              id: String,
+              error: T.nilable(OpenAI::Beta::AgentSessionEnvironmentState::Error),
+              status: OpenAI::Beta::AgentSessionEnvironmentState::Status::TaggedSymbol,
+              type: String
+            }
+          )
+        end
+        def to_hash
+        end
+
+        class Error < OpenAI::Internal::Type::BaseModel
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::Beta::AgentSessionEnvironmentState::Error,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+          # A machine-readable error code.
+          sig { returns(String) }
+          attr_accessor :code
+
+          # A human-readable error message.
+          sig { returns(String) }
+          attr_accessor :message
+
+          # The error type.
+          sig { returns(String) }
+          attr_accessor :type
+
+          # An error reported while preparing a session environment.
+          sig do
+            params(
+
+              code: String,
+
+              message: String,
+
+              type: String
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(
+
+            # A machine-readable error code.
+            code:,
+
+            # A human-readable error message.
+            message:,
+
+            # The error type.
+
+            type:
+          )
+          end
+
+          sig do
+            override.returns(
+              {code: String, message: String, type: String}
+            )
+          end
+          def to_hash
+          end
+
+        end
+
+        # The environment's connection status.
+        module Status
+          extend OpenAI::Internal::Type::Enum
+
+          TaggedSymbol = T.type_alias { T.all(Symbol, OpenAI::Beta::AgentSessionEnvironmentState::Status) }
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          # The environment is being prepared.
+          PENDING = T.let(:pending, OpenAI::Beta::AgentSessionEnvironmentState::Status::TaggedSymbol)
+
+          # The environment is ready to connect.
+          READY = T.let(:ready, OpenAI::Beta::AgentSessionEnvironmentState::Status::TaggedSymbol)
+
+          # The environment is connected.
+          CONNECTED = T.let(:connected, OpenAI::Beta::AgentSessionEnvironmentState::Status::TaggedSymbol)
+
+          # The environment is disconnected.
+          DISCONNECTED = T.let(:disconnected, OpenAI::Beta::AgentSessionEnvironmentState::Status::TaggedSymbol)
+
+          # The environment failed to connect.
+          FAILED = T.let(:failed, OpenAI::Beta::AgentSessionEnvironmentState::Status::TaggedSymbol)
+
+          sig { override.returns(T::Array[OpenAI::Beta::AgentSessionEnvironmentState::Status::TaggedSymbol]) }
+          def self.values
+          end
+        end
+
+      end
+
+    end
+
+  end
+end