openai 0.89.0 → 0.90.0

data/rbi/openai/models/beta/agent_session_item.rbi

@@ -0,0 +1,239 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Beta
+
+      # An item associated with a session turn.
+      module AgentSessionItem
+        extend OpenAI::Internal::Type::Union
+
+        Variants = T.type_alias do
+          T.any(
+            OpenAI::Beta::AgentSessionMessage,
+            OpenAI::Beta::AgentReasoningItem,
+            OpenAI::Beta::AgentFunctionCallItem,
+            OpenAI::Beta::AgentSessionItem::FunctionCallOutput,
+            OpenAI::Beta::AgentSessionItem::AgentMessage,
+            OpenAI::Beta::AgentMcpCallItem,
+            OpenAI::Beta::AgentWebSearchCallItem,
+            OpenAI::Beta::AgentCommandExecutionItem,
+            OpenAI::Beta::AgentCreateSubagentCallItem,
+            OpenAI::Beta::AgentSendSubagentInputCallItem,
+            OpenAI::Beta::AgentResumeSubagentCallItem,
+            OpenAI::Beta::AgentWaitForSubagentsCallItem,
+            OpenAI::Beta::AgentInterruptSubagentCallItem,
+            OpenAI::Beta::AgentCloseSubagentCallItem
+          )
+        end
+
+        class FunctionCallOutput < OpenAI::Internal::Type::BaseModel
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::Beta::AgentSessionItem::FunctionCallOutput,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+          # The ID of the function call output item.
+          sig { returns(String) }
+          attr_accessor :id
+
+          # The ID of the function call that produced this output.
+          sig { returns(String) }
+          attr_accessor :call_id
+
+          # The error message, if the call failed.
+          sig { returns(T.nilable(String)) }
+          attr_accessor :error
+
+          # The text or model-input content supplied as a function result.
+          sig { returns(T.nilable(OpenAI::Beta::AgentFunctionCallOutput::Variants)) }
+          attr_accessor :output
+
+          # The status of the function call.
+          sig { returns(OpenAI::Beta::AgentFunctionCallStatus::TaggedSymbol) }
+          attr_accessor :status
+
+          # The ID of the turn that contains this item.
+          sig { returns(String) }
+          attr_accessor :turn_id
+
+          # The item type. Always `function_call_output`.
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          # The result supplied for a function call.
+          sig do
+            params(
+
+              id: String,
+
+              call_id: String,
+
+              error: T.nilable(String),
+
+              output: T.nilable(
+                T.any(
+                  String,
+                  T::Array[
+                    T.any(OpenAI::Beta::InputContent::InputText::OrHash, OpenAI::Beta::InputContent::InputImage::OrHash)
+                  ]
+                )
+              ),
+
+              status: OpenAI::Beta::AgentFunctionCallStatus::OrSymbol,
+
+              turn_id: String,
+
+              type: Symbol
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(
+
+            # The ID of the function call output item.
+            id:,
+
+            # The ID of the function call that produced this output.
+            call_id:,
+
+            # The error message, if the call failed.
+            error:,
+
+            # The text or model-input content supplied as a function result.
+            output:,
+
+            # The status of the function call.
+            status:,
+
+            # The ID of the turn that contains this item.
+            turn_id:,
+
+            # The item type. Always `function_call_output`.
+
+            type: :function_call_output
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                id: String,
+                call_id: String,
+                error: T.nilable(String),
+                output: T.nilable(OpenAI::Beta::AgentFunctionCallOutput::Variants),
+                status: OpenAI::Beta::AgentFunctionCallStatus::TaggedSymbol,
+                turn_id: String,
+                type: Symbol
+              }
+            )
+          end
+          def to_hash
+          end
+
+        end
+
+        class AgentMessage < OpenAI::Internal::Type::BaseModel
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::Beta::AgentSessionItem::AgentMessage,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+          # The ID of the message.
+          sig { returns(String) }
+          attr_accessor :id
+
+          # The content exchanged between the agents.
+          sig { returns(T::Array[OpenAI::Beta::AgentContent::Variants]) }
+          attr_accessor :content
+
+          # The ID or name of the receiving agent.
+          sig { returns(String) }
+          attr_accessor :recipient_agent_id
+
+          # The ID or name of the sending agent.
+          sig { returns(String) }
+          attr_accessor :sender_agent_id
+
+          # The ID of the turn that contains this item.
+          sig { returns(String) }
+          attr_accessor :turn_id
+
+          # The item type. Always `agent_message`.
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          # A message exchanged between agent threads.
+          sig do
+            params(
+
+              id: String,
+
+              content: T::Array[
+                T.any(OpenAI::Beta::OutputText::OrHash, OpenAI::Beta::AgentContent::EncryptedContent::OrHash)
+              ],
+
+              recipient_agent_id: String,
+
+              sender_agent_id: String,
+
+              turn_id: String,
+
+              type: Symbol
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(
+
+            # The ID of the message.
+            id:,
+
+            # The content exchanged between the agents.
+            content:,
+
+            # The ID or name of the receiving agent.
+            recipient_agent_id:,
+
+            # The ID or name of the sending agent.
+            sender_agent_id:,
+
+            # The ID of the turn that contains this item.
+            turn_id:,
+
+            # The item type. Always `agent_message`.
+
+            type: :agent_message
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                id: String,
+                content: T::Array[OpenAI::Beta::AgentContent::Variants],
+                recipient_agent_id: String,
+                sender_agent_id: String,
+                turn_id: String,
+                type: Symbol
+              }
+            )
+          end
+          def to_hash
+          end
+
+        end
+
+        sig { override.returns(T::Array[OpenAI::Beta::AgentSessionItem::Variants]) }
+        def self.variants
+        end
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/beta/agent_session_message.rbi

@@ -0,0 +1,153 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Beta
+
+      class AgentSessionMessage < OpenAI::Internal::Type::BaseModel
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Beta::AgentSessionMessage,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        # The ID of this item, or null for legacy user messages whose ID was not recorded.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :id
+
+        # The content of the message. User messages contain input text or images;
+        # assistant messages contain output text.
+        sig { returns(T::Array[OpenAI::Beta::AgentSessionMessageContent::Variants]) }
+        attr_accessor :content
+
+        # The phase of an assistant message.
+        sig { returns(T.nilable(OpenAI::Beta::AgentSessionMessage::Phase::TaggedSymbol)) }
+        attr_accessor :phase
+
+        # The role of the message author.
+        sig { returns(OpenAI::Beta::AgentSessionMessage::Role::TaggedSymbol) }
+        attr_accessor :role
+
+        # The status of the message. User messages are always `completed`.
+        sig { returns(OpenAI::Beta::AgentOutputItemStatus::TaggedSymbol) }
+        attr_accessor :status
+
+        # The ID of the turn that contains this item.
+        sig { returns(String) }
+        attr_accessor :turn_id
+
+        # The item type. Always `message`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # A user or assistant message recorded in a session.
+        sig do
+          params(
+
+            id: T.nilable(String),
+
+            content: T::Array[
+              T.any(
+                OpenAI::Beta::AgentSessionMessageContent::InputText::OrHash,
+                OpenAI::Beta::AgentSessionMessageContent::InputImage::OrHash,
+                OpenAI::Beta::AgentSessionMessageContent::OutputText::OrHash
+              )
+            ],
+
+            phase: T.nilable(OpenAI::Beta::AgentSessionMessage::Phase::OrSymbol),
+
+            role: OpenAI::Beta::AgentSessionMessage::Role::OrSymbol,
+
+            status: OpenAI::Beta::AgentOutputItemStatus::OrSymbol,
+
+            turn_id: String,
+
+            type: Symbol
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          # The ID of this item, or null for legacy user messages whose ID was not recorded.
+          id:,
+
+          # The content of the message. User messages contain input text or images;
+          # assistant messages contain output text.
+          content:,
+
+          # The phase of an assistant message.
+          phase:,
+
+          # The role of the message author.
+          role:,
+
+          # The status of the message. User messages are always `completed`.
+          status:,
+
+          # The ID of the turn that contains this item.
+          turn_id:,
+
+          # The item type. Always `message`.
+
+          type: :message
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              id: T.nilable(String),
+              content: T::Array[OpenAI::Beta::AgentSessionMessageContent::Variants],
+              phase: T.nilable(OpenAI::Beta::AgentSessionMessage::Phase::TaggedSymbol),
+              role: OpenAI::Beta::AgentSessionMessage::Role::TaggedSymbol,
+              status: OpenAI::Beta::AgentOutputItemStatus::TaggedSymbol,
+              turn_id: String,
+              type: Symbol
+            }
+          )
+        end
+        def to_hash
+        end
+
+        # The phase of an assistant message.
+        module Phase
+          extend OpenAI::Internal::Type::Enum
+
+          TaggedSymbol = T.type_alias { T.all(Symbol, OpenAI::Beta::AgentSessionMessage::Phase) }
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          # Commentary produced while the agent works.
+          COMMENTARY = T.let(:commentary, OpenAI::Beta::AgentSessionMessage::Phase::TaggedSymbol)
+
+          # The agent's final answer.
+          FINAL_ANSWER = T.let(:final_answer, OpenAI::Beta::AgentSessionMessage::Phase::TaggedSymbol)
+
+          sig { override.returns(T::Array[OpenAI::Beta::AgentSessionMessage::Phase::TaggedSymbol]) }
+          def self.values
+          end
+        end
+
+        # The role of the message author.
+        module Role
+          extend OpenAI::Internal::Type::Enum
+
+          TaggedSymbol = T.type_alias { T.all(Symbol, OpenAI::Beta::AgentSessionMessage::Role) }
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          USER = T.let(:user, OpenAI::Beta::AgentSessionMessage::Role::TaggedSymbol)
+          ASSISTANT = T.let(:assistant, OpenAI::Beta::AgentSessionMessage::Role::TaggedSymbol)
+
+          sig { override.returns(T::Array[OpenAI::Beta::AgentSessionMessage::Role::TaggedSymbol]) }
+          def self.values
+          end
+        end
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/beta/agent_session_message_content.rbi

@@ -0,0 +1,172 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Beta
+
+      # A content part in a session message.
+      module AgentSessionMessageContent
+        extend OpenAI::Internal::Type::Union
+
+        Variants = T.type_alias do
+          T.any(
+            OpenAI::Beta::AgentSessionMessageContent::InputText,
+            OpenAI::Beta::AgentSessionMessageContent::InputImage,
+            OpenAI::Beta::AgentSessionMessageContent::OutputText
+          )
+        end
+
+        class InputText < OpenAI::Internal::Type::BaseModel
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::Beta::AgentSessionMessageContent::InputText,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+          # The text supplied by the user.
+          sig { returns(String) }
+          attr_accessor :text
+
+          # The type of the object. Always `input_text`.
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          # Text supplied by the user.
+          sig do
+            params(
+
+              text: String,
+
+              type: Symbol
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(
+
+            # The text supplied by the user.
+            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::AgentSessionMessageContent::InputImage,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+          # The URL of the image supplied by the user, 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
+
+          # An image supplied by the user.
+          sig do
+            params(
+
+              image_url: String,
+
+              type: Symbol
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(
+
+            # The URL of the image supplied by the user, 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
+
+        class OutputText < OpenAI::Internal::Type::BaseModel
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::Beta::AgentSessionMessageContent::OutputText,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+          # The text produced by the assistant.
+          sig { returns(String) }
+          attr_accessor :text
+
+          # The type of the object. Always `output_text`.
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          # Text produced by the assistant.
+          sig do
+            params(
+
+              text: String,
+
+              type: Symbol
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(
+
+            # The text produced by the assistant.
+            text:,
+
+            # The type of the object. Always `output_text`.
+
+            type: :output_text
+          )
+          end
+
+          sig do
+            override.returns(
+              {text: String, type: Symbol}
+            )
+          end
+          def to_hash
+          end
+
+        end
+
+        sig { override.returns(T::Array[OpenAI::Beta::AgentSessionMessageContent::Variants]) }
+        def self.variants
+        end
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/beta/agent_session_requires_action_event.rbi

@@ -0,0 +1,71 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Beta
+
+      class AgentSessionRequiresActionEvent < OpenAI::Internal::Type::BaseModel
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Beta::AgentSessionRequiresActionEvent,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        # The unique ID of the event.
+        sig { returns(String) }
+        attr_accessor :event_id
+
+        # The session and its current required actions.
+        sig { returns(OpenAI::Beta::AgentSession) }
+        attr_reader :session
+
+        sig { params(session: OpenAI::Beta::AgentSession::OrHash).void }
+        attr_writer :session
+
+        # The type of the object. Always `agent.session.requires_action`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # Emitted when a session is waiting for one or more required actions.
+        sig do
+          params(
+
+            event_id: String,
+
+            session: OpenAI::Beta::AgentSession::OrHash,
+
+            type: Symbol
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          # The unique ID of the event.
+          event_id:,
+
+          # The session and its current required actions.
+          session:,
+
+          # The type of the object. Always `agent.session.requires_action`.
+
+          type: :"agent.session.requires_action"
+        )
+        end
+
+        sig do
+          override.returns(
+            {event_id: String, session: OpenAI::Beta::AgentSession, type: Symbol}
+          )
+        end
+        def to_hash
+        end
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/beta/agent_session_subagent_active_event.rbi

@@ -0,0 +1,71 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Beta
+
+      class AgentSessionSubagentActiveEvent < OpenAI::Internal::Type::BaseModel
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Beta::AgentSessionSubagentActiveEvent,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        # The unique ID of the event.
+        sig { returns(String) }
+        attr_accessor :event_id
+
+        # The subagent that resumed.
+        sig { returns(OpenAI::Beta::Subagent) }
+        attr_reader :subagent
+
+        sig { params(subagent: OpenAI::Beta::Subagent::OrHash).void }
+        attr_writer :subagent
+
+        # The type of the object. Always `agent.session.subagent.active`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # Emitted when a closed subagent successfully resumes.
+        sig do
+          params(
+
+            event_id: String,
+
+            subagent: OpenAI::Beta::Subagent::OrHash,
+
+            type: Symbol
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          # The unique ID of the event.
+          event_id:,
+
+          # The subagent that resumed.
+          subagent:,
+
+          # The type of the object. Always `agent.session.subagent.active`.
+
+          type: :"agent.session.subagent.active"
+        )
+        end
+
+        sig do
+          override.returns(
+            {event_id: String, subagent: OpenAI::Beta::Subagent, type: Symbol}
+          )
+        end
+        def to_hash
+        end
+
+      end
+
+    end
+
+  end
+end