openai 0.89.0 → 0.90.0

data/rbi/openai/models/beta/agent_interrupt_subagent_call_item.rbi

@@ -0,0 +1,103 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Beta
+
+      class AgentInterruptSubagentCallItem < OpenAI::Internal::Type::BaseModel
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Beta::AgentInterruptSubagentCallItem,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        # The ID of the tool call item.
+        sig { returns(String) }
+        attr_accessor :id
+
+        # The ID of the agent to interrupt.
+        sig { returns(String) }
+        attr_accessor :recipient_agent_id
+
+        # The ID of the agent requesting the interrupt.
+        sig { returns(String) }
+        attr_accessor :sender_agent_id
+
+        # The status of the tool 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 `interrupt_subagent_call`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # A request to interrupt a subagent's current turn. The subagent remains
+        # available.
+        sig do
+          params(
+
+            id: String,
+
+            recipient_agent_id: String,
+
+            sender_agent_id: String,
+
+            status: OpenAI::Beta::AgentFunctionCallStatus::OrSymbol,
+
+            turn_id: String,
+
+            type: Symbol
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          # The ID of the tool call item.
+          id:,
+
+          # The ID of the agent to interrupt.
+          recipient_agent_id:,
+
+          # The ID of the agent requesting the interrupt.
+          sender_agent_id:,
+
+          # The status of the tool call.
+          status:,
+
+          # The ID of the turn that contains this item.
+          turn_id:,
+
+          # The item type. Always `interrupt_subagent_call`.
+
+          type: :interrupt_subagent_call
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              id: String,
+              recipient_agent_id: String,
+              sender_agent_id: String,
+              status: OpenAI::Beta::AgentFunctionCallStatus::TaggedSymbol,
+              turn_id: String,
+              type: Symbol
+            }
+          )
+        end
+        def to_hash
+        end
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/beta/agent_list_params.rbi

@@ -0,0 +1,102 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Beta
+
+      class AgentListParams < OpenAI::Internal::Type::BaseModel
+
+        extend OpenAI::Internal::Type::RequestParameters::Converter
+        include OpenAI::Internal::Type::RequestParameters
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Beta::AgentListParams,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        # Return resources after this resource ID in the selected order.
+        sig { returns(T.nilable(String)) }
+        attr_reader :after
+
+        sig { params(after: String).void }
+        attr_writer :after
+
+        # The maximum number of resources to return.
+        sig { returns(T.nilable(Integer)) }
+        attr_accessor :limit
+
+        # The order in which resources are returned. Defaults to `desc`.
+        sig { returns(T.nilable(OpenAI::Beta::AgentListParams::Order::OrSymbol)) }
+        attr_reader :order
+
+        sig { params(order: OpenAI::Beta::AgentListParams::Order::OrSymbol).void }
+        attr_writer :order
+
+        sig do
+          params(
+
+            after: String,
+
+            limit: T.nilable(Integer),
+
+            order: OpenAI::Beta::AgentListParams::Order::OrSymbol,
+
+            request_options: OpenAI::RequestOptions::OrHash
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          # Return resources after this resource ID in the selected order.
+          after: nil,
+
+          # The maximum number of resources to return.
+          limit: nil,
+
+          # The order in which resources are returned. Defaults to `desc`.
+          order: nil,
+
+          request_options: {}
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              after: String,
+              limit: T.nilable(Integer),
+              order: OpenAI::Beta::AgentListParams::Order::OrSymbol,
+              request_options: OpenAI::RequestOptions
+            }
+          )
+        end
+        def to_hash
+        end
+
+        # The order in which resources are returned. Defaults to `desc`.
+        module Order
+          extend OpenAI::Internal::Type::Enum
+
+          TaggedSymbol = T.type_alias { T.all(Symbol, OpenAI::Beta::AgentListParams::Order) }
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          # Returns resources in ascending order.
+          ASC = T.let(:asc, OpenAI::Beta::AgentListParams::Order::TaggedSymbol)
+
+          # Returns resources in descending order.
+          DESC = T.let(:desc, OpenAI::Beta::AgentListParams::Order::TaggedSymbol)
+
+          sig { override.returns(T::Array[OpenAI::Beta::AgentListParams::Order::TaggedSymbol]) }
+          def self.values
+          end
+        end
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/beta/agent_mcp_call_item.rbi

@@ -0,0 +1,132 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Beta
+
+      class AgentMcpCallItem < OpenAI::Internal::Type::BaseModel
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Beta::AgentMcpCallItem,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        # The ID of the MCP call item.
+        sig { returns(String) }
+        attr_accessor :id
+
+        # The arguments passed to the MCP tool.
+        sig { returns(T.anything) }
+        attr_accessor :arguments
+
+        # The error returned by the MCP tool, if any.
+        sig { returns(T.anything) }
+        attr_accessor :error
+
+        # The name of the MCP tool.
+        sig { returns(String) }
+        attr_accessor :name
+
+        # The output returned by the MCP tool, if any.
+        sig { returns(T.anything) }
+        attr_accessor :output
+
+        # The label of the MCP server.
+        sig { returns(String) }
+        attr_accessor :server_label
+
+        # The status of the MCP tool 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 `mcp_call`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # A call to a tool on an MCP server.
+        sig do
+          params(
+
+            id: String,
+
+            arguments: T.anything,
+
+            error: T.anything,
+
+            name: String,
+
+            output: T.anything,
+
+            server_label: String,
+
+            status: OpenAI::Beta::AgentFunctionCallStatus::OrSymbol,
+
+            turn_id: String,
+
+            type: Symbol
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          # The ID of the MCP call item.
+          id:,
+
+          # The arguments passed to the MCP tool.
+          arguments:,
+
+          # The error returned by the MCP tool, if any.
+          error:,
+
+          # The name of the MCP tool.
+          name:,
+
+          # The output returned by the MCP tool, if any.
+          output:,
+
+          # The label of the MCP server.
+          server_label:,
+
+          # The status of the MCP tool call.
+          status:,
+
+          # The ID of the turn that contains this item.
+          turn_id:,
+
+          # The item type. Always `mcp_call`.
+
+          type: :mcp_call
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              id: String,
+              arguments: T.anything,
+              error: T.anything,
+              name: String,
+              output: T.anything,
+              server_label: String,
+              status: OpenAI::Beta::AgentFunctionCallStatus::TaggedSymbol,
+              turn_id: String,
+              type: Symbol
+            }
+          )
+        end
+        def to_hash
+        end
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/beta/agent_output_command_execution_output_delta_event.rbi

@@ -0,0 +1,112 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Beta
+
+      class AgentOutputCommandExecutionOutputDeltaEvent < OpenAI::Internal::Type::BaseModel
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Beta::AgentOutputCommandExecutionOutputDeltaEvent,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        # The output 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 command execution 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.output.command_execution_output.delta`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # Emitted when command execution produces an output delta.
+        sig do
+          params(
+
+            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 output text that was appended.
+          delta:,
+
+          # The unique ID of the event.
+          event_id:,
+
+          # The ID of the command execution 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.output.command_execution_output.delta`.
+
+          type: :"agent.output.command_execution_output.delta"
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              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_output_item.rbi

@@ -0,0 +1,38 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Beta
+
+      # An output item produced by an agent.
+      module AgentOutputItem
+        extend OpenAI::Internal::Type::Union
+
+        Variants = T.type_alias do
+          T.any(
+            OpenAI::Beta::AgentSessionAssistantMessage,
+            OpenAI::Beta::AgentReasoningItem,
+            OpenAI::Beta::AgentFunctionCallItem,
+            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
+
+        sig { override.returns(T::Array[OpenAI::Beta::AgentOutputItem::Variants]) }
+        def self.variants
+        end
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/beta/agent_output_item_status.rbi

@@ -0,0 +1,32 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Beta
+
+      # The status of an agent output item.
+      module AgentOutputItemStatus
+        extend OpenAI::Internal::Type::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, OpenAI::Beta::AgentOutputItemStatus) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        # The item is in progress.
+        IN_PROGRESS = T.let(:in_progress, OpenAI::Beta::AgentOutputItemStatus::TaggedSymbol)
+
+        # The item is complete.
+        COMPLETED = T.let(:completed, OpenAI::Beta::AgentOutputItemStatus::TaggedSymbol)
+
+        # The item stopped before completing.
+        INCOMPLETE = T.let(:incomplete, OpenAI::Beta::AgentOutputItemStatus::TaggedSymbol)
+
+        sig { override.returns(T::Array[OpenAI::Beta::AgentOutputItemStatus::TaggedSymbol]) }
+        def self.values
+        end
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/beta/agent_reasoning.rbi

@@ -0,0 +1,103 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Beta
+
+      class AgentReasoning < OpenAI::Internal::Type::BaseModel
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Beta::AgentReasoning,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        # The amount of reasoning effort used by an agent.
+        sig { returns(T.nilable(OpenAI::Beta::AgentReasoning::Effort::TaggedSymbol)) }
+        attr_accessor :effort
+
+        # The reasoning summary format requested from an agent.
+        sig { returns(T.nilable(OpenAI::Beta::AgentReasoning::Summary::TaggedSymbol)) }
+        attr_accessor :summary
+
+        # The reasoning configuration used by an agent.
+        sig do
+          params(
+
+            effort: T.nilable(OpenAI::Beta::AgentReasoning::Effort::OrSymbol),
+
+            summary: T.nilable(OpenAI::Beta::AgentReasoning::Summary::OrSymbol)
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          # The amount of reasoning effort used by an agent.
+          effort:,
+
+          # The reasoning summary format requested from an agent.
+
+          summary:
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              effort: T.nilable(OpenAI::Beta::AgentReasoning::Effort::TaggedSymbol),
+              summary: T.nilable(OpenAI::Beta::AgentReasoning::Summary::TaggedSymbol)
+            }
+          )
+        end
+        def to_hash
+        end
+
+        # The amount of reasoning effort used by an agent.
+        module Effort
+          extend OpenAI::Internal::Type::Enum
+
+          TaggedSymbol = T.type_alias { T.all(Symbol, OpenAI::Beta::AgentReasoning::Effort) }
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          NONE = T.let(:none, OpenAI::Beta::AgentReasoning::Effort::TaggedSymbol)
+          MINIMAL = T.let(:minimal, OpenAI::Beta::AgentReasoning::Effort::TaggedSymbol)
+          LOW = T.let(:low, OpenAI::Beta::AgentReasoning::Effort::TaggedSymbol)
+          MEDIUM = T.let(:medium, OpenAI::Beta::AgentReasoning::Effort::TaggedSymbol)
+          HIGH = T.let(:high, OpenAI::Beta::AgentReasoning::Effort::TaggedSymbol)
+          XHIGH = T.let(:xhigh, OpenAI::Beta::AgentReasoning::Effort::TaggedSymbol)
+          MAX = T.let(:max, OpenAI::Beta::AgentReasoning::Effort::TaggedSymbol)
+
+          sig { override.returns(T::Array[OpenAI::Beta::AgentReasoning::Effort::TaggedSymbol]) }
+          def self.values
+          end
+        end
+
+        # The reasoning summary format requested from an agent.
+        module Summary
+          extend OpenAI::Internal::Type::Enum
+
+          TaggedSymbol = T.type_alias { T.all(Symbol, OpenAI::Beta::AgentReasoning::Summary) }
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          # Returns a concise reasoning summary when supported.
+          CONCISE = T.let(:concise, OpenAI::Beta::AgentReasoning::Summary::TaggedSymbol)
+
+          # Returns a detailed reasoning summary when supported.
+          DETAILED = T.let(:detailed, OpenAI::Beta::AgentReasoning::Summary::TaggedSymbol)
+
+          # Automatically selects the most detailed summary supported by the model.
+          AUTO = T.let(:auto, OpenAI::Beta::AgentReasoning::Summary::TaggedSymbol)
+
+          sig { override.returns(T::Array[OpenAI::Beta::AgentReasoning::Summary::TaggedSymbol]) }
+          def self.values
+          end
+        end
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/beta/agent_reasoning_item.rbi

@@ -0,0 +1,92 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Beta
+
+      class AgentReasoningItem < OpenAI::Internal::Type::BaseModel
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Beta::AgentReasoningItem,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        # The ID of the reasoning item.
+        sig { returns(String) }
+        attr_accessor :id
+
+        # The status of an agent output item.
+        sig { returns(T.nilable(OpenAI::Beta::AgentOutputItemStatus::TaggedSymbol)) }
+        attr_accessor :status
+
+        # The reasoning summaries produced by the agent.
+        sig { returns(T::Array[OpenAI::Beta::SummaryText]) }
+        attr_accessor :summary
+
+        # The ID of the turn that contains this item.
+        sig { returns(String) }
+        attr_accessor :turn_id
+
+        # The item type. Always `reasoning`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # A reasoning item produced by the agent.
+        sig do
+          params(
+
+            id: String,
+
+            status: T.nilable(OpenAI::Beta::AgentOutputItemStatus::OrSymbol),
+
+            summary: T::Array[OpenAI::Beta::SummaryText::OrHash],
+
+            turn_id: String,
+
+            type: Symbol
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          # The ID of the reasoning item.
+          id:,
+
+          # The status of an agent output item.
+          status:,
+
+          # The reasoning summaries produced by the agent.
+          summary:,
+
+          # The ID of the turn that contains this item.
+          turn_id:,
+
+          # The item type. Always `reasoning`.
+
+          type: :reasoning
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              id: String,
+              status: T.nilable(OpenAI::Beta::AgentOutputItemStatus::TaggedSymbol),
+              summary: T::Array[OpenAI::Beta::SummaryText],
+              turn_id: String,
+              type: Symbol
+            }
+          )
+        end
+        def to_hash
+        end
+
+      end
+
+    end
+
+  end
+end