openai 0.20.0 → 0.21.0

data/rbi/openai/models/realtime/realtime_mcp_list_tools.rbi

@@ -0,0 +1,131 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    module Realtime
+      class RealtimeMcpListTools < OpenAI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              OpenAI::Realtime::RealtimeMcpListTools,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+        # The label of the MCP server.
+        sig { returns(String) }
+        attr_accessor :server_label
+
+        # The tools available on the server.
+        sig { returns(T::Array[OpenAI::Realtime::RealtimeMcpListTools::Tool]) }
+        attr_accessor :tools
+
+        # The type of the item. Always `mcp_list_tools`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # The unique ID of the list.
+        sig { returns(T.nilable(String)) }
+        attr_reader :id
+
+        sig { params(id: String).void }
+        attr_writer :id
+
+        # A Realtime item listing tools available on an MCP server.
+        sig do
+          params(
+            server_label: String,
+            tools:
+              T::Array[OpenAI::Realtime::RealtimeMcpListTools::Tool::OrHash],
+            id: String,
+            type: Symbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # The label of the MCP server.
+          server_label:,
+          # The tools available on the server.
+          tools:,
+          # The unique ID of the list.
+          id: nil,
+          # The type of the item. Always `mcp_list_tools`.
+          type: :mcp_list_tools
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              server_label: String,
+              tools: T::Array[OpenAI::Realtime::RealtimeMcpListTools::Tool],
+              type: Symbol,
+              id: String
+            }
+          )
+        end
+        def to_hash
+        end
+
+        class Tool < OpenAI::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                OpenAI::Realtime::RealtimeMcpListTools::Tool,
+                OpenAI::Internal::AnyHash
+              )
+            end
+
+          # The JSON schema describing the tool's input.
+          sig { returns(T.anything) }
+          attr_accessor :input_schema
+
+          # The name of the tool.
+          sig { returns(String) }
+          attr_accessor :name
+
+          # Additional annotations about the tool.
+          sig { returns(T.nilable(T.anything)) }
+          attr_accessor :annotations
+
+          # The description of the tool.
+          sig { returns(T.nilable(String)) }
+          attr_accessor :description
+
+          # A tool available on an MCP server.
+          sig do
+            params(
+              input_schema: T.anything,
+              name: String,
+              annotations: T.nilable(T.anything),
+              description: T.nilable(String)
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            # The JSON schema describing the tool's input.
+            input_schema:,
+            # The name of the tool.
+            name:,
+            # Additional annotations about the tool.
+            annotations: nil,
+            # The description of the tool.
+            description: nil
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                input_schema: T.anything,
+                name: String,
+                annotations: T.nilable(T.anything),
+                description: T.nilable(String)
+              }
+            )
+          end
+          def to_hash
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/openai/models/realtime/realtime_mcp_protocol_error.rbi

@@ -0,0 +1,40 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    module Realtime
+      class RealtimeMcpProtocolError < OpenAI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              OpenAI::Realtime::RealtimeMcpProtocolError,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+        sig { returns(Integer) }
+        attr_accessor :code
+
+        sig { returns(String) }
+        attr_accessor :message
+
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        sig do
+          params(code: Integer, message: String, type: Symbol).returns(
+            T.attached_class
+          )
+        end
+        def self.new(code:, message:, type: :protocol_error)
+        end
+
+        sig do
+          override.returns({ code: Integer, message: String, type: Symbol })
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/openai/models/realtime/realtime_mcp_tool_call.rbi

@@ -0,0 +1,145 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    module Realtime
+      class RealtimeMcpToolCall < OpenAI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              OpenAI::Realtime::RealtimeMcpToolCall,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+        # The unique ID of the tool call.
+        sig { returns(String) }
+        attr_accessor :id
+
+        # A JSON string of the arguments passed to the tool.
+        sig { returns(String) }
+        attr_accessor :arguments
+
+        # The name of the tool that was run.
+        sig { returns(String) }
+        attr_accessor :name
+
+        # The label of the MCP server running the tool.
+        sig { returns(String) }
+        attr_accessor :server_label
+
+        # The type of the item. Always `mcp_tool_call`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # The ID of an associated approval request, if any.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :approval_request_id
+
+        # The error from the tool call, if any.
+        sig do
+          returns(
+            T.nilable(
+              T.any(
+                OpenAI::Realtime::RealtimeMcpProtocolError,
+                OpenAI::Realtime::RealtimeMcpToolExecutionError,
+                OpenAI::Realtime::RealtimeMcphttpError
+              )
+            )
+          )
+        end
+        attr_accessor :error
+
+        # The output from the tool call.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :output
+
+        # A Realtime item representing an invocation of a tool on an MCP server.
+        sig do
+          params(
+            id: String,
+            arguments: String,
+            name: String,
+            server_label: String,
+            approval_request_id: T.nilable(String),
+            error:
+              T.nilable(
+                T.any(
+                  OpenAI::Realtime::RealtimeMcpProtocolError::OrHash,
+                  OpenAI::Realtime::RealtimeMcpToolExecutionError::OrHash,
+                  OpenAI::Realtime::RealtimeMcphttpError::OrHash
+                )
+              ),
+            output: T.nilable(String),
+            type: Symbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # The unique ID of the tool call.
+          id:,
+          # A JSON string of the arguments passed to the tool.
+          arguments:,
+          # The name of the tool that was run.
+          name:,
+          # The label of the MCP server running the tool.
+          server_label:,
+          # The ID of an associated approval request, if any.
+          approval_request_id: nil,
+          # The error from the tool call, if any.
+          error: nil,
+          # The output from the tool call.
+          output: nil,
+          # The type of the item. Always `mcp_tool_call`.
+          type: :mcp_tool_call
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              id: String,
+              arguments: String,
+              name: String,
+              server_label: String,
+              type: Symbol,
+              approval_request_id: T.nilable(String),
+              error:
+                T.nilable(
+                  T.any(
+                    OpenAI::Realtime::RealtimeMcpProtocolError,
+                    OpenAI::Realtime::RealtimeMcpToolExecutionError,
+                    OpenAI::Realtime::RealtimeMcphttpError
+                  )
+                ),
+              output: T.nilable(String)
+            }
+          )
+        end
+        def to_hash
+        end
+
+        # The error from the tool call, if any.
+        module Error
+          extend OpenAI::Internal::Type::Union
+
+          Variants =
+            T.type_alias do
+              T.any(
+                OpenAI::Realtime::RealtimeMcpProtocolError,
+                OpenAI::Realtime::RealtimeMcpToolExecutionError,
+                OpenAI::Realtime::RealtimeMcphttpError
+              )
+            end
+
+          sig do
+            override.returns(
+              T::Array[OpenAI::Realtime::RealtimeMcpToolCall::Error::Variants]
+            )
+          end
+          def self.variants
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/openai/models/realtime/realtime_mcp_tool_execution_error.rbi

@@ -0,0 +1,31 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    module Realtime
+      class RealtimeMcpToolExecutionError < OpenAI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              OpenAI::Realtime::RealtimeMcpToolExecutionError,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+        sig { returns(String) }
+        attr_accessor :message
+
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        sig { params(message: String, type: Symbol).returns(T.attached_class) }
+        def self.new(message:, type: :tool_execution_error)
+        end
+
+        sig { override.returns({ message: String, type: Symbol }) }
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/openai/models/realtime/realtime_mcphttp_error.rbi

@@ -0,0 +1,40 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    module Realtime
+      class RealtimeMcphttpError < OpenAI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              OpenAI::Realtime::RealtimeMcphttpError,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+        sig { returns(Integer) }
+        attr_accessor :code
+
+        sig { returns(String) }
+        attr_accessor :message
+
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        sig do
+          params(code: Integer, message: String, type: Symbol).returns(
+            T.attached_class
+          )
+        end
+        def self.new(code:, message:, type: :http_error)
+        end
+
+        sig do
+          override.returns({ code: Integer, message: String, type: Symbol })
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end