openai 0.89.0 → 0.90.0

data/rbi/openai/models/beta/agent_session_turn_failed_event.rbi

@@ -0,0 +1,108 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Beta
+
+      class AgentSessionTurnFailedEvent < OpenAI::Internal::Type::BaseModel
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Beta::AgentSessionTurnFailedEvent,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        # 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 failed turn.
+        sig { returns(OpenAI::Beta::Agents::Sessions::Turn) }
+        attr_reader :turn
+
+        sig { params(turn: OpenAI::Beta::Agents::Sessions::Turn::OrHash).void }
+        attr_writer :turn
+
+        # The ID of the turn associated with the event.
+        sig { returns(String) }
+        attr_accessor :turn_id
+
+        # The type of the object. Always `agent.session.turn.failed`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # Recorded token usage for a session or turn. Usage is best effort and may change.
+        sig { returns(T.nilable(OpenAI::Beta::TokenUsage)) }
+        attr_reader :usage
+
+        sig { params(usage: T.nilable(OpenAI::Beta::TokenUsage::OrHash)).void }
+        attr_writer :usage
+
+        # Emitted when a turn fails.
+        sig do
+          params(
+
+            event_id: String,
+
+            session_id: String,
+
+            turn: OpenAI::Beta::Agents::Sessions::Turn::OrHash,
+
+            turn_id: String,
+
+            usage: T.nilable(OpenAI::Beta::TokenUsage::OrHash),
+
+            type: Symbol
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          # The unique ID of the event.
+          event_id:,
+
+          # The ID of the session associated with the event.
+          session_id:,
+
+          # The failed turn.
+          turn:,
+
+          # The ID of the turn associated with the event.
+          turn_id:,
+
+          # Recorded token usage for a session or turn. Usage is best effort and may change.
+          usage:,
+
+          # The type of the object. Always `agent.session.turn.failed`.
+
+          type: :"agent.session.turn.failed"
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              event_id: String,
+              session_id: String,
+              turn: OpenAI::Beta::Agents::Sessions::Turn,
+              turn_id: String,
+              type: Symbol,
+              usage: T.nilable(OpenAI::Beta::TokenUsage)
+            }
+          )
+        end
+        def to_hash
+        end
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/beta/agent_session_turn_in_progress_event.rbi

@@ -0,0 +1,95 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Beta
+
+      class AgentSessionTurnInProgressEvent < OpenAI::Internal::Type::BaseModel
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Beta::AgentSessionTurnInProgressEvent,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        # 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 turn at the time it started running.
+        sig { returns(OpenAI::Beta::Agents::Sessions::Turn) }
+        attr_reader :turn
+
+        sig { params(turn: OpenAI::Beta::Agents::Sessions::Turn::OrHash).void }
+        attr_writer :turn
+
+        # The ID of the turn associated with the event.
+        sig { returns(String) }
+        attr_accessor :turn_id
+
+        # The type of the object. Always `agent.session.turn.in_progress`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # Emitted when a turn starts running.
+        sig do
+          params(
+
+            event_id: String,
+
+            session_id: String,
+
+            turn: OpenAI::Beta::Agents::Sessions::Turn::OrHash,
+
+            turn_id: String,
+
+            type: Symbol
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          # The unique ID of the event.
+          event_id:,
+
+          # The ID of the session associated with the event.
+          session_id:,
+
+          # The turn at the time it started running.
+          turn:,
+
+          # The ID of the turn associated with the event.
+          turn_id:,
+
+          # The type of the object. Always `agent.session.turn.in_progress`.
+
+          type: :"agent.session.turn.in_progress"
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              event_id: String,
+              session_id: String,
+              turn: OpenAI::Beta::Agents::Sessions::Turn,
+              turn_id: String,
+              type: Symbol
+            }
+          )
+        end
+        def to_hash
+        end
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/beta/agent_session_turn_item_added_event.rbi

@@ -0,0 +1,117 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Beta
+
+      class AgentSessionTurnItemAddedEvent < OpenAI::Internal::Type::BaseModel
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Beta::AgentSessionTurnItemAddedEvent,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        # The unique ID of the event.
+        sig { returns(String) }
+        attr_accessor :event_id
+
+        # The item that was added.
+        sig { returns(OpenAI::Beta::AgentSessionItem::Variants) }
+        attr_accessor :item
+
+        # The index of the item in the turn output, when the item is agent output.
+        sig { returns(T.nilable(Integer)) }
+        attr_accessor :output_index
+
+        # 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.turn.item.added`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # Emitted when an item is added to a turn.
+        sig do
+          params(
+
+            event_id: String,
+
+            item: T.any(
+              OpenAI::Beta::AgentSessionMessage::OrHash,
+              OpenAI::Beta::AgentReasoningItem::OrHash,
+              OpenAI::Beta::AgentFunctionCallItem::OrHash,
+              OpenAI::Beta::AgentSessionItem::FunctionCallOutput::OrHash,
+              OpenAI::Beta::AgentSessionItem::AgentMessage::OrHash,
+              OpenAI::Beta::AgentMcpCallItem::OrHash,
+              OpenAI::Beta::AgentWebSearchCallItem::OrHash,
+              OpenAI::Beta::AgentCommandExecutionItem::OrHash,
+              OpenAI::Beta::AgentCreateSubagentCallItem::OrHash,
+              OpenAI::Beta::AgentSendSubagentInputCallItem::OrHash,
+              OpenAI::Beta::AgentResumeSubagentCallItem::OrHash,
+              OpenAI::Beta::AgentWaitForSubagentsCallItem::OrHash,
+              OpenAI::Beta::AgentInterruptSubagentCallItem::OrHash,
+              OpenAI::Beta::AgentCloseSubagentCallItem::OrHash
+            ),
+
+            output_index: T.nilable(Integer),
+
+            session_id: String,
+
+            turn_id: T.nilable(String),
+
+            type: Symbol
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          # The unique ID of the event.
+          event_id:,
+
+          # The item that was added.
+          item:,
+
+          # The index of the item in the turn output, when the item is agent output.
+          output_index:,
+
+          # 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.turn.item.added`.
+
+          type: :"agent.session.turn.item.added"
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              event_id: String,
+              item: OpenAI::Beta::AgentSessionItem::Variants,
+              output_index: T.nilable(Integer),
+              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_turn_item_done_event.rbi

@@ -0,0 +1,115 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Beta
+
+      class AgentSessionTurnItemDoneEvent < OpenAI::Internal::Type::BaseModel
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Beta::AgentSessionTurnItemDoneEvent,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        # The unique ID of the event.
+        sig { returns(String) }
+        attr_accessor :event_id
+
+        # The completed output item.
+        sig { returns(OpenAI::Beta::AgentOutputItem::Variants) }
+        attr_accessor :item
+
+        # The index of the output item in the turn output.
+        sig { returns(Integer) }
+        attr_accessor :output_index
+
+        # 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.turn.item.done`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # Emitted when an output item is complete.
+        sig do
+          params(
+
+            event_id: String,
+
+            item: T.any(
+              OpenAI::Beta::AgentSessionAssistantMessage::OrHash,
+              OpenAI::Beta::AgentReasoningItem::OrHash,
+              OpenAI::Beta::AgentFunctionCallItem::OrHash,
+              OpenAI::Beta::AgentMcpCallItem::OrHash,
+              OpenAI::Beta::AgentWebSearchCallItem::OrHash,
+              OpenAI::Beta::AgentCommandExecutionItem::OrHash,
+              OpenAI::Beta::AgentCreateSubagentCallItem::OrHash,
+              OpenAI::Beta::AgentSendSubagentInputCallItem::OrHash,
+              OpenAI::Beta::AgentResumeSubagentCallItem::OrHash,
+              OpenAI::Beta::AgentWaitForSubagentsCallItem::OrHash,
+              OpenAI::Beta::AgentInterruptSubagentCallItem::OrHash,
+              OpenAI::Beta::AgentCloseSubagentCallItem::OrHash
+            ),
+
+            output_index: Integer,
+
+            session_id: String,
+
+            turn_id: T.nilable(String),
+
+            type: Symbol
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          # The unique ID of the event.
+          event_id:,
+
+          # The completed output item.
+          item:,
+
+          # The index of the output item in the turn output.
+          output_index:,
+
+          # 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.turn.item.done`.
+
+          type: :"agent.session.turn.item.done"
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              event_id: String,
+              item: OpenAI::Beta::AgentOutputItem::Variants,
+              output_index: Integer,
+              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_turn_output_text_delta_event.rbi

@@ -0,0 +1,122 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Beta
+
+      class AgentSessionTurnOutputTextDeltaEvent < OpenAI::Internal::Type::BaseModel
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Beta::AgentSessionTurnOutputTextDeltaEvent,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        # The index of the content part in the message.
+        sig { returns(Integer) }
+        attr_accessor :content_index
+
+        # The text that was appended.
+        sig { returns(String) }
+        attr_accessor :delta
+
+        # The unique ID of the event.
+        sig { returns(String) }
+        attr_accessor :event_id
+
+        # The ID of the message item.
+        sig { returns(String) }
+        attr_accessor :item_id
+
+        # The index of the item in the turn output.
+        sig { returns(Integer) }
+        attr_accessor :output_index
+
+        # 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.turn.output_text.delta`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # Emitted when text is appended to an output text content part.
+        sig do
+          params(
+
+            content_index: Integer,
+
+            delta: String,
+
+            event_id: String,
+
+            item_id: String,
+
+            output_index: Integer,
+
+            session_id: String,
+
+            turn_id: T.nilable(String),
+
+            type: Symbol
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          # The index of the content part in the message.
+          content_index:,
+
+          # The text that was appended.
+          delta:,
+
+          # The unique ID of the event.
+          event_id:,
+
+          # The ID of the message item.
+          item_id:,
+
+          # The index of the item in the turn output.
+          output_index:,
+
+          # 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.turn.output_text.delta`.
+
+          type: :"agent.session.turn.output_text.delta"
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              content_index: Integer,
+              delta: String,
+              event_id: String,
+              item_id: String,
+              output_index: Integer,
+              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_turn_output_text_done_event.rbi

@@ -0,0 +1,122 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Beta
+
+      class AgentSessionTurnOutputTextDoneEvent < OpenAI::Internal::Type::BaseModel
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Beta::AgentSessionTurnOutputTextDoneEvent,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        # The index of the content part in the message.
+        sig { returns(Integer) }
+        attr_accessor :content_index
+
+        # The unique ID of the event.
+        sig { returns(String) }
+        attr_accessor :event_id
+
+        # The ID of the message item.
+        sig { returns(String) }
+        attr_accessor :item_id
+
+        # The index of the item in the turn output.
+        sig { returns(Integer) }
+        attr_accessor :output_index
+
+        # The ID of the session associated with the event.
+        sig { returns(String) }
+        attr_accessor :session_id
+
+        # The complete output text.
+        sig { returns(String) }
+        attr_accessor :text
+
+        # 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.turn.output_text.done`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # Emitted when an output text content part is complete.
+        sig do
+          params(
+
+            content_index: Integer,
+
+            event_id: String,
+
+            item_id: String,
+
+            output_index: Integer,
+
+            session_id: String,
+
+            text: String,
+
+            turn_id: T.nilable(String),
+
+            type: Symbol
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          # The index of the content part in the message.
+          content_index:,
+
+          # The unique ID of the event.
+          event_id:,
+
+          # The ID of the message item.
+          item_id:,
+
+          # The index of the item in the turn output.
+          output_index:,
+
+          # The ID of the session associated with the event.
+          session_id:,
+
+          # The complete output text.
+          text:,
+
+          # The ID of the turn associated with the event, when applicable.
+          turn_id:,
+
+          # The type of the object. Always `agent.session.turn.output_text.done`.
+
+          type: :"agent.session.turn.output_text.done"
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              content_index: Integer,
+              event_id: String,
+              item_id: String,
+              output_index: Integer,
+              session_id: String,
+              text: String,
+              turn_id: T.nilable(String),
+              type: Symbol
+            }
+          )
+        end
+        def to_hash
+        end
+
+      end
+
+    end
+
+  end
+end