openai 0.67.0 → 0.69.0

data/rbi/openai/models/beta/beta_response_code_interpreter_call_completed_event.rbi

@@ -0,0 +1,128 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    BetaResponseCodeInterpreterCallCompletedEvent =
+      Beta::BetaResponseCodeInterpreterCallCompletedEvent
+
+    module Beta
+      class BetaResponseCodeInterpreterCallCompletedEvent < OpenAI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              OpenAI::Beta::BetaResponseCodeInterpreterCallCompletedEvent,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+        # The unique identifier of the code interpreter tool call item.
+        sig { returns(String) }
+        attr_accessor :item_id
+
+        # The index of the output item in the response for which the code interpreter call
+        # is completed.
+        sig { returns(Integer) }
+        attr_accessor :output_index
+
+        # The sequence number of this event, used to order streaming events.
+        sig { returns(Integer) }
+        attr_accessor :sequence_number
+
+        # The type of the event. Always `response.code_interpreter_call.completed`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # The agent that owns this multi-agent streaming event.
+        sig do
+          returns(
+            T.nilable(
+              OpenAI::Beta::BetaResponseCodeInterpreterCallCompletedEvent::Agent
+            )
+          )
+        end
+        attr_reader :agent
+
+        sig do
+          params(
+            agent:
+              T.nilable(
+                OpenAI::Beta::BetaResponseCodeInterpreterCallCompletedEvent::Agent::OrHash
+              )
+          ).void
+        end
+        attr_writer :agent
+
+        # Emitted when the code interpreter call is completed.
+        sig do
+          params(
+            item_id: String,
+            output_index: Integer,
+            sequence_number: Integer,
+            agent:
+              T.nilable(
+                OpenAI::Beta::BetaResponseCodeInterpreterCallCompletedEvent::Agent::OrHash
+              ),
+            type: Symbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # The unique identifier of the code interpreter tool call item.
+          item_id:,
+          # The index of the output item in the response for which the code interpreter call
+          # is completed.
+          output_index:,
+          # The sequence number of this event, used to order streaming events.
+          sequence_number:,
+          # The agent that owns this multi-agent streaming event.
+          agent: nil,
+          # The type of the event. Always `response.code_interpreter_call.completed`.
+          type: :"response.code_interpreter_call.completed"
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              item_id: String,
+              output_index: Integer,
+              sequence_number: Integer,
+              type: Symbol,
+              agent:
+                T.nilable(
+                  OpenAI::Beta::BetaResponseCodeInterpreterCallCompletedEvent::Agent
+                )
+            }
+          )
+        end
+        def to_hash
+        end
+
+        class Agent < OpenAI::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                OpenAI::Beta::BetaResponseCodeInterpreterCallCompletedEvent::Agent,
+                OpenAI::Internal::AnyHash
+              )
+            end
+
+          # The canonical name of the agent that produced this item.
+          sig { returns(String) }
+          attr_accessor :agent_name
+
+          # The agent that owns this multi-agent streaming event.
+          sig { params(agent_name: String).returns(T.attached_class) }
+          def self.new(
+            # The canonical name of the agent that produced this item.
+            agent_name:
+          )
+          end
+
+          sig { override.returns({ agent_name: String }) }
+          def to_hash
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/openai/models/beta/beta_response_code_interpreter_call_in_progress_event.rbi

@@ -0,0 +1,128 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    BetaResponseCodeInterpreterCallInProgressEvent =
+      Beta::BetaResponseCodeInterpreterCallInProgressEvent
+
+    module Beta
+      class BetaResponseCodeInterpreterCallInProgressEvent < OpenAI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              OpenAI::Beta::BetaResponseCodeInterpreterCallInProgressEvent,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+        # The unique identifier of the code interpreter tool call item.
+        sig { returns(String) }
+        attr_accessor :item_id
+
+        # The index of the output item in the response for which the code interpreter call
+        # is in progress.
+        sig { returns(Integer) }
+        attr_accessor :output_index
+
+        # The sequence number of this event, used to order streaming events.
+        sig { returns(Integer) }
+        attr_accessor :sequence_number
+
+        # The type of the event. Always `response.code_interpreter_call.in_progress`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # The agent that owns this multi-agent streaming event.
+        sig do
+          returns(
+            T.nilable(
+              OpenAI::Beta::BetaResponseCodeInterpreterCallInProgressEvent::Agent
+            )
+          )
+        end
+        attr_reader :agent
+
+        sig do
+          params(
+            agent:
+              T.nilable(
+                OpenAI::Beta::BetaResponseCodeInterpreterCallInProgressEvent::Agent::OrHash
+              )
+          ).void
+        end
+        attr_writer :agent
+
+        # Emitted when a code interpreter call is in progress.
+        sig do
+          params(
+            item_id: String,
+            output_index: Integer,
+            sequence_number: Integer,
+            agent:
+              T.nilable(
+                OpenAI::Beta::BetaResponseCodeInterpreterCallInProgressEvent::Agent::OrHash
+              ),
+            type: Symbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # The unique identifier of the code interpreter tool call item.
+          item_id:,
+          # The index of the output item in the response for which the code interpreter call
+          # is in progress.
+          output_index:,
+          # The sequence number of this event, used to order streaming events.
+          sequence_number:,
+          # The agent that owns this multi-agent streaming event.
+          agent: nil,
+          # The type of the event. Always `response.code_interpreter_call.in_progress`.
+          type: :"response.code_interpreter_call.in_progress"
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              item_id: String,
+              output_index: Integer,
+              sequence_number: Integer,
+              type: Symbol,
+              agent:
+                T.nilable(
+                  OpenAI::Beta::BetaResponseCodeInterpreterCallInProgressEvent::Agent
+                )
+            }
+          )
+        end
+        def to_hash
+        end
+
+        class Agent < OpenAI::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                OpenAI::Beta::BetaResponseCodeInterpreterCallInProgressEvent::Agent,
+                OpenAI::Internal::AnyHash
+              )
+            end
+
+          # The canonical name of the agent that produced this item.
+          sig { returns(String) }
+          attr_accessor :agent_name
+
+          # The agent that owns this multi-agent streaming event.
+          sig { params(agent_name: String).returns(T.attached_class) }
+          def self.new(
+            # The canonical name of the agent that produced this item.
+            agent_name:
+          )
+          end
+
+          sig { override.returns({ agent_name: String }) }
+          def to_hash
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/openai/models/beta/beta_response_code_interpreter_call_interpreting_event.rbi

@@ -0,0 +1,128 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    BetaResponseCodeInterpreterCallInterpretingEvent =
+      Beta::BetaResponseCodeInterpreterCallInterpretingEvent
+
+    module Beta
+      class BetaResponseCodeInterpreterCallInterpretingEvent < OpenAI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              OpenAI::Beta::BetaResponseCodeInterpreterCallInterpretingEvent,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+        # The unique identifier of the code interpreter tool call item.
+        sig { returns(String) }
+        attr_accessor :item_id
+
+        # The index of the output item in the response for which the code interpreter is
+        # interpreting code.
+        sig { returns(Integer) }
+        attr_accessor :output_index
+
+        # The sequence number of this event, used to order streaming events.
+        sig { returns(Integer) }
+        attr_accessor :sequence_number
+
+        # The type of the event. Always `response.code_interpreter_call.interpreting`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # The agent that owns this multi-agent streaming event.
+        sig do
+          returns(
+            T.nilable(
+              OpenAI::Beta::BetaResponseCodeInterpreterCallInterpretingEvent::Agent
+            )
+          )
+        end
+        attr_reader :agent
+
+        sig do
+          params(
+            agent:
+              T.nilable(
+                OpenAI::Beta::BetaResponseCodeInterpreterCallInterpretingEvent::Agent::OrHash
+              )
+          ).void
+        end
+        attr_writer :agent
+
+        # Emitted when the code interpreter is actively interpreting the code snippet.
+        sig do
+          params(
+            item_id: String,
+            output_index: Integer,
+            sequence_number: Integer,
+            agent:
+              T.nilable(
+                OpenAI::Beta::BetaResponseCodeInterpreterCallInterpretingEvent::Agent::OrHash
+              ),
+            type: Symbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # The unique identifier of the code interpreter tool call item.
+          item_id:,
+          # The index of the output item in the response for which the code interpreter is
+          # interpreting code.
+          output_index:,
+          # The sequence number of this event, used to order streaming events.
+          sequence_number:,
+          # The agent that owns this multi-agent streaming event.
+          agent: nil,
+          # The type of the event. Always `response.code_interpreter_call.interpreting`.
+          type: :"response.code_interpreter_call.interpreting"
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              item_id: String,
+              output_index: Integer,
+              sequence_number: Integer,
+              type: Symbol,
+              agent:
+                T.nilable(
+                  OpenAI::Beta::BetaResponseCodeInterpreterCallInterpretingEvent::Agent
+                )
+            }
+          )
+        end
+        def to_hash
+        end
+
+        class Agent < OpenAI::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                OpenAI::Beta::BetaResponseCodeInterpreterCallInterpretingEvent::Agent,
+                OpenAI::Internal::AnyHash
+              )
+            end
+
+          # The canonical name of the agent that produced this item.
+          sig { returns(String) }
+          attr_accessor :agent_name
+
+          # The agent that owns this multi-agent streaming event.
+          sig { params(agent_name: String).returns(T.attached_class) }
+          def self.new(
+            # The canonical name of the agent that produced this item.
+            agent_name:
+          )
+          end
+
+          sig { override.returns({ agent_name: String }) }
+          def to_hash
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/openai/models/beta/beta_response_code_interpreter_tool_call.rbi

@@ -0,0 +1,315 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    BetaResponseCodeInterpreterToolCall =
+      Beta::BetaResponseCodeInterpreterToolCall
+
+    module Beta
+      class BetaResponseCodeInterpreterToolCall < OpenAI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              OpenAI::Beta::BetaResponseCodeInterpreterToolCall,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+        # The unique ID of the code interpreter tool call.
+        sig { returns(String) }
+        attr_accessor :id
+
+        # The code to run, or null if not available.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :code
+
+        # The ID of the container used to run the code.
+        sig { returns(String) }
+        attr_accessor :container_id
+
+        # The outputs generated by the code interpreter, such as logs or images. Can be
+        # null if no outputs are available.
+        sig do
+          returns(
+            T.nilable(
+              T::Array[
+                T.any(
+                  OpenAI::Beta::BetaResponseCodeInterpreterToolCall::Output::Logs,
+                  OpenAI::Beta::BetaResponseCodeInterpreterToolCall::Output::Image
+                )
+              ]
+            )
+          )
+        end
+        attr_accessor :outputs
+
+        # The status of the code interpreter tool call. Valid values are `in_progress`,
+        # `completed`, `incomplete`, `interpreting`, and `failed`.
+        sig do
+          returns(
+            OpenAI::Beta::BetaResponseCodeInterpreterToolCall::Status::OrSymbol
+          )
+        end
+        attr_accessor :status
+
+        # The type of the code interpreter tool call. Always `code_interpreter_call`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # The agent that produced this item.
+        sig do
+          returns(
+            T.nilable(OpenAI::Beta::BetaResponseCodeInterpreterToolCall::Agent)
+          )
+        end
+        attr_reader :agent
+
+        sig do
+          params(
+            agent:
+              T.nilable(
+                OpenAI::Beta::BetaResponseCodeInterpreterToolCall::Agent::OrHash
+              )
+          ).void
+        end
+        attr_writer :agent
+
+        # A tool call to run code.
+        sig do
+          params(
+            id: String,
+            code: T.nilable(String),
+            container_id: String,
+            outputs:
+              T.nilable(
+                T::Array[
+                  T.any(
+                    OpenAI::Beta::BetaResponseCodeInterpreterToolCall::Output::Logs::OrHash,
+                    OpenAI::Beta::BetaResponseCodeInterpreterToolCall::Output::Image::OrHash
+                  )
+                ]
+              ),
+            status:
+              OpenAI::Beta::BetaResponseCodeInterpreterToolCall::Status::OrSymbol,
+            agent:
+              T.nilable(
+                OpenAI::Beta::BetaResponseCodeInterpreterToolCall::Agent::OrHash
+              ),
+            type: Symbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # The unique ID of the code interpreter tool call.
+          id:,
+          # The code to run, or null if not available.
+          code:,
+          # The ID of the container used to run the code.
+          container_id:,
+          # The outputs generated by the code interpreter, such as logs or images. Can be
+          # null if no outputs are available.
+          outputs:,
+          # The status of the code interpreter tool call. Valid values are `in_progress`,
+          # `completed`, `incomplete`, `interpreting`, and `failed`.
+          status:,
+          # The agent that produced this item.
+          agent: nil,
+          # The type of the code interpreter tool call. Always `code_interpreter_call`.
+          type: :code_interpreter_call
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              id: String,
+              code: T.nilable(String),
+              container_id: String,
+              outputs:
+                T.nilable(
+                  T::Array[
+                    T.any(
+                      OpenAI::Beta::BetaResponseCodeInterpreterToolCall::Output::Logs,
+                      OpenAI::Beta::BetaResponseCodeInterpreterToolCall::Output::Image
+                    )
+                  ]
+                ),
+              status:
+                OpenAI::Beta::BetaResponseCodeInterpreterToolCall::Status::OrSymbol,
+              type: Symbol,
+              agent:
+                T.nilable(
+                  OpenAI::Beta::BetaResponseCodeInterpreterToolCall::Agent
+                )
+            }
+          )
+        end
+        def to_hash
+        end
+
+        # The logs output from the code interpreter.
+        module Output
+          extend OpenAI::Internal::Type::Union
+
+          Variants =
+            T.type_alias do
+              T.any(
+                OpenAI::Beta::BetaResponseCodeInterpreterToolCall::Output::Logs,
+                OpenAI::Beta::BetaResponseCodeInterpreterToolCall::Output::Image
+              )
+            end
+
+          class Logs < OpenAI::Internal::Type::BaseModel
+            OrHash =
+              T.type_alias do
+                T.any(
+                  OpenAI::Beta::BetaResponseCodeInterpreterToolCall::Output::Logs,
+                  OpenAI::Internal::AnyHash
+                )
+              end
+
+            # The logs output from the code interpreter.
+            sig { returns(String) }
+            attr_accessor :logs
+
+            # The type of the output. Always `logs`.
+            sig { returns(Symbol) }
+            attr_accessor :type
+
+            # The logs output from the code interpreter.
+            sig { params(logs: String, type: Symbol).returns(T.attached_class) }
+            def self.new(
+              # The logs output from the code interpreter.
+              logs:,
+              # The type of the output. Always `logs`.
+              type: :logs
+            )
+            end
+
+            sig { override.returns({ logs: String, type: Symbol }) }
+            def to_hash
+            end
+          end
+
+          class Image < OpenAI::Internal::Type::BaseModel
+            OrHash =
+              T.type_alias do
+                T.any(
+                  OpenAI::Beta::BetaResponseCodeInterpreterToolCall::Output::Image,
+                  OpenAI::Internal::AnyHash
+                )
+              end
+
+            # The type of the output. Always `image`.
+            sig { returns(Symbol) }
+            attr_accessor :type
+
+            # The URL of the image output from the code interpreter.
+            sig { returns(String) }
+            attr_accessor :url
+
+            # The image output from the code interpreter.
+            sig { params(url: String, type: Symbol).returns(T.attached_class) }
+            def self.new(
+              # The URL of the image output from the code interpreter.
+              url:,
+              # The type of the output. Always `image`.
+              type: :image
+            )
+            end
+
+            sig { override.returns({ type: Symbol, url: String }) }
+            def to_hash
+            end
+          end
+
+          sig do
+            override.returns(
+              T::Array[
+                OpenAI::Beta::BetaResponseCodeInterpreterToolCall::Output::Variants
+              ]
+            )
+          end
+          def self.variants
+          end
+        end
+
+        # The status of the code interpreter tool call. Valid values are `in_progress`,
+        # `completed`, `incomplete`, `interpreting`, and `failed`.
+        module Status
+          extend OpenAI::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(
+                Symbol,
+                OpenAI::Beta::BetaResponseCodeInterpreterToolCall::Status
+              )
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          IN_PROGRESS =
+            T.let(
+              :in_progress,
+              OpenAI::Beta::BetaResponseCodeInterpreterToolCall::Status::TaggedSymbol
+            )
+          COMPLETED =
+            T.let(
+              :completed,
+              OpenAI::Beta::BetaResponseCodeInterpreterToolCall::Status::TaggedSymbol
+            )
+          INCOMPLETE =
+            T.let(
+              :incomplete,
+              OpenAI::Beta::BetaResponseCodeInterpreterToolCall::Status::TaggedSymbol
+            )
+          INTERPRETING =
+            T.let(
+              :interpreting,
+              OpenAI::Beta::BetaResponseCodeInterpreterToolCall::Status::TaggedSymbol
+            )
+          FAILED =
+            T.let(
+              :failed,
+              OpenAI::Beta::BetaResponseCodeInterpreterToolCall::Status::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                OpenAI::Beta::BetaResponseCodeInterpreterToolCall::Status::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+
+        class Agent < OpenAI::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                OpenAI::Beta::BetaResponseCodeInterpreterToolCall::Agent,
+                OpenAI::Internal::AnyHash
+              )
+            end
+
+          # The canonical name of the agent that produced this item.
+          sig { returns(String) }
+          attr_accessor :agent_name
+
+          # The agent that produced this item.
+          sig { params(agent_name: String).returns(T.attached_class) }
+          def self.new(
+            # The canonical name of the agent that produced this item.
+            agent_name:
+          )
+          end
+
+          sig { override.returns({ agent_name: String }) }
+          def to_hash
+          end
+        end
+      end
+    end
+  end
+end