onyxcord 2.0.0 → 2.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '00639da6b7f1bb86015ad2789db3c8a31a8a2865d26d594bb0bdf15914dbb534'
-  data.tar.gz: 0ac2f4e68b91633c3d1006faf2def1d6df6a99a9898fc2c38de819d5048f41f4
+  metadata.gz: 2e5d5e025fe9ad9abb42d0fca6da5fe8bf9f32bfbe527de27a2da742bfe5f262
+  data.tar.gz: e7b494fd1d4821c2c517f24ceca4a6da27720f552618b71f5a5452c5a3ef915b
 SHA512:
-  metadata.gz: ae1eab8467d518c3bd98148274b3bc152e1c9d8b72696c27fe621e069a7d2ff75ff33dddfda22b00702f25a85b38702a31accaf1d00d0366d831cc96b38cea3b
-  data.tar.gz: dc2bb8086656c80b8d97c7992f99a75aed3efd7481a9de4c52713edbbc02536ab6074d27931b88430b92a72a3b5412e58fdff8ee5ccb4e936edd19f08c7edbc0
+  metadata.gz: '059ec009fb6fd52704a2906bdfc8fb6a20f0e06dd2ac783e1f466ce4cfabbe71c2fa9cb269a332e69fc3a05cdef7d8e394cfc3a3e1bfb11c94c0c7d43c0dd26d'
+  data.tar.gz: c4f5fb863ec9a636d4b7591b50afe16d4a0174c28390f5d42aa84f7ff32a2e904cfe71de4104b4425a7661cb82e71a9b114abc6b874888c52d8ad74683f14d58

data/.gitignore

@@ -9,6 +9,7 @@
 /profiles/
 /tmp/
 /.idea/
+/obsidian/
 .DS_Store
 *.gem
 **.sw*

data/CHANGELOG.md

@@ -1,5 +1,52 @@
 # Changelog
 
+## 2.0.5 - 2026-06-28
+
+### Async Runtime (Infraestrutura nao-bloqueante)
+
+- **`OnyxCord::AsyncRuntime`**: modulo central que gerencia o reactor `async` com `run`, `async` e `sleep`, reaproveitando reactor existente quando disponivel.
+- **`EventExecutor::AsyncPool`**: novo pool de workers baseado em `Async::Queue` e fibers, sem threads.
+- **Gateway**: `run_async` nao cria mais `Thread.new` — usa `@task = AsyncRuntime.async { run }`. Todos os `sleep` trocados por `AsyncRuntime.sleep`.
+- **WebSocket**: usa `AsyncRuntime.async` em vez de `Async do` solto na classe.
+- **API REST**: `request` agora delega para `request_async` automaticamente quando dentro de um reactor. `request_async` usa rate limiter async, `AsyncRuntime.sleep`, e retry com limite em 502.
+- **Rate Limiter Async**: novo `OnyxCord::RateLimiter::AsyncRest` que evita `mutex.synchronize { sleep }` bloqueante.
+- **Bot**: `run`/`stop`/`join` refatorados para o runtime async. `send_temporary_message` e `voice_connect` usam sleeps async.
+- Compatibilidade sync mantida: a API publica continua funcionando de forma sincrona quando chamada fora de um reactor.
+
+### Modern Application Commands DSL
+
+- **`bot.slash`, `bot.user_command`, `bot.message_command`**: nova DSL para comandos modernos com definicao e handler unificados.
+- **`bot.sync_application_commands!`**: sincroniza todos os commands registrados com a API do Discord de uma vez.
+- **`bot.bulk_overwrite_global_application_commands`** e **`bot.bulk_overwrite_guild_application_commands`**: wrappers para bulk overwrite.
+- **`ApplicationCommands::Context`**: wrapper com `respond`, `defer`, `edit_original`, `delete_original`, `followup` e acesso a `options`, `guild`, `channel`, `user`.
+- **`Interaction#edit_original`**, **`Interaction#delete_original`**, **`Interaction#followup`**: novos aliases dos metodos originais.
+- API legacy (`register_application_command` + `application_command`) mantida com compatibilidade total.
+
+### Exemplo da nova DSL
+
+```ruby
+bot.slash :ban, description: "Bane um membro", default_member_permissions: [:ban_members] do
+  user :member, "Membro que sera banido", required: true
+  string :reason, "Motivo do banimento", max_length: 512
+
+  execute do |ctx|
+    ctx.defer(ephemeral: true)
+    member = ctx.options[:member]
+    reason = ctx.options[:reason] || "Sem motivo informado"
+    ctx.guild.ban(member, reason: reason)
+    ctx.edit_original(content: "Membro banido com sucesso.")
+  end
+end
+
+bot.sync_application_commands!(server_id: ENV.fetch('DISCORD_SERVER_ID'))
+```
+
+### Validacao
+
+- `bundle exec rspec`: 460 exemplos, 0 falhas, 3 pendentes.
+- `ruby -c lib/onyxcord/**/*.rb`: todos os arquivos com sintaxe OK.
+- `gem build onyxcord.gemspec`: sucesso.
+
 ## 2.0.0 - 2026-06-28
 
 ### Arquitetura & Performance (Major Refactoring)

data/README.md

@@ -22,6 +22,8 @@ Simple to start, deep enough to control.
 - Friendly Ruby API for Discord bots.
 - Traditional object events for productivity.
 - Raw gateway events for performance and lower allocation.
+- **Modern async runtime** built on `async` gem with non-blocking gateway, REST and event dispatch.
+- **New modern slash command DSL** with `bot.slash`, `execute`, and `bot.sync_application_commands!`.
 - Components V2 support with `Text Display`, `Container`, `Section`, `Media Gallery`, `File`, `Separator`, and `Thumbnail`.
 - Modern modal components, including `Label`, `Text Display`, modal selects, file upload, radio group, checkbox group, and checkbox.
 - Webhooks with embeds, files, and components.
@@ -112,6 +114,25 @@ bot.application_command(:feedback) do |event|
 end
 ```
 
+### Modern Command DSL
+
+```ruby
+bot.slash :ban, description: 'Ban a member', default_member_permissions: [:ban_members] do
+  user :member, 'Member to ban', required: true
+  string :reason, 'Ban reason', max_length: 512
+
+  execute do |ctx|
+    ctx.defer(ephemeral: true)
+    member = ctx.options[:member]
+    reason = ctx.options[:reason] || 'No reason provided'
+    ctx.guild.ban(member, reason: reason)
+    ctx.edit_original(content: 'Member banned.')
+  end
+end
+
+bot.sync_application_commands!(server_id: ENV.fetch('DISCORD_SERVER_ID'))
+```
+
 ### Community
 
 Join the Discord server for support, updates, examples, and feedback: https://discord.gg/Jy2tpCUtzM
@@ -131,6 +152,8 @@ Simples para comecar, profundo para controlar.
 - API Ruby amigavel para bots do Discord.
 - Eventos tradicionais com objetos para quem quer produtividade.
 - Eventos raw para quem quer performance e menos alocacao.
+- **Runtime async moderno** baseado na gem `async`: gateway, REST e dispatch de eventos nao-bloqueantes.
+- **Nova DSL moderna de slash commands** com `bot.slash`, `execute` e `bot.sync_application_commands!`.
 - Components V2 com `Text Display`, `Container`, `Section`, `Media Gallery`, `File`, `Separator` e `Thumbnail`.
 - Novos componentes de modal, incluindo `Label`, `Text Display`, selects em modal, upload, radio group, checkbox group e checkbox.
 - Webhooks com embeds, arquivos e componentes.
@@ -221,6 +244,25 @@ bot.application_command(:feedback) do |event|
 end
 ```
 
+### DSL Moderna de Comandos
+
+```ruby
+bot.slash :ban, description: 'Bane um membro', default_member_permissions: [:ban_members] do
+  user :member, 'Membro que sera banido', required: true
+  string :reason, 'Motivo do banimento', max_length: 512
+
+  execute do |ctx|
+    ctx.defer(ephemeral: true)
+    member = ctx.options[:member]
+    reason = ctx.options[:reason] || 'Sem motivo informado'
+    ctx.guild.ban(member, reason: reason)
+    ctx.edit_original(content: 'Membro banido com sucesso.')
+  end
+end
+
+bot.sync_application_commands!(server_id: ENV.fetch('DISCORD_SERVER_ID'))
+```
+
 ### Comunidade
 
 Entre no servidor do Discord para suporte, atualizacoes, exemplos e feedback: https://discord.gg/Jy2tpCUtzM
@@ -237,9 +279,11 @@ Simple para empezar, profundo para controlar.
 
 ### Caracteristicas
 
-- API Ruby amigable para bots de Discord.
+- API Ruby amigavel para bots de Discord.
 - Eventos tradicionales con objetos para productividad.
 - Eventos raw para rendimiento y menos asignaciones.
+- **Runtime async moderno** basado en la gem `async`: gateway, REST y dispatch de eventos no bloqueantes.
+- **Nueva DSL moderna de slash commands** con `bot.slash`, `execute` y `bot.sync_application_commands!`.
 - Components V2 con `Text Display`, `Container`, `Section`, `Media Gallery`, `File`, `Separator` y `Thumbnail`.
 - Componentes modernos de modal, incluyendo `Label`, `Text Display`, selects en modal, subida de archivos, radio group, checkbox group y checkbox.
 - Webhooks con embeds, archivos y componentes.
@@ -330,6 +374,25 @@ bot.application_command(:feedback) do |event|
 end
 ```
 
+### DSL Moderna de Comandos
+
+```ruby
+bot.slash :ban, description: 'Banear a un miembro', default_member_permissions: [:ban_members] do
+  user :member, 'Miembro a banear', required: true
+  string :reason, 'Motivo del baneo', max_length: 512
+
+  execute do |ctx|
+    ctx.defer(ephemeral: true)
+    member = ctx.options[:member]
+    reason = ctx.options[:reason] || 'Sin motivo'
+    ctx.guild.ban(member, reason: reason)
+    ctx.edit_original(content: 'Miembro baneado.')
+  end
+end
+
+bot.sync_application_commands!(server_id: ENV.fetch('DISCORD_SERVER_ID'))
+```
+
 ### Comunidad
 
 Unete al servidor de Discord para soporte, actualizaciones, ejemplos y feedback: https://discord.gg/Jy2tpCUtzM

data/lib/onyxcord/api.rb

@@ -2,10 +2,12 @@
 
 require 'onyxcord/http'
 require 'onyxcord/json'
+require 'onyxcord/async/runtime'
 require 'time'
 
 require 'onyxcord/errors'
 require 'onyxcord/rate_limiter/rest'
+require 'onyxcord/rate_limiter/async_rest'
 
 # List of methods representing endpoints in Discord's API
 module OnyxCord::API
@@ -61,16 +63,25 @@ module OnyxCord::API
   # Resets all rate limit mutexes
   def reset_mutexes
     @rate_limiter = OnyxCord::RateLimiter::Rest.new
+    @async_rate_limiter = OnyxCord::RateLimiter::AsyncRest.new
   end
 
   def rate_limiter
     @rate_limiter ||= OnyxCord::RateLimiter::Rest.new
   end
 
+  def async_rate_limiter
+    @async_rate_limiter ||= OnyxCord::RateLimiter::AsyncRest.new
+  end
+
   def rate_limiter_stats
     rate_limiter.stats
   end
 
+  def async_rate_limiter_stats
+    async_rate_limiter.stats
+  end
+
   # Wait a specified amount of time synchronised with the specified mutex.
   def sync_wait(time, mutex)
     mutex.synchronize { sleep time }
@@ -110,11 +121,18 @@ module OnyxCord::API
 
   # Make an API request, including rate limit handling.
   def request(key, major_parameter, type, *attributes)
-    # Parse attributes: URL is first, body is second (if present), rest is headers hash
+    if Async::Task.current?
+      request_async(key, major_parameter, type, *attributes)
+    else
+      OnyxCord::AsyncRuntime.run { request_async(key, major_parameter, type, *attributes) }
+    end
+  end
+
+  # Async version of request.
+  def request_async(key, major_parameter, type, *attributes)
     url = attributes.shift
     headers_or_body = attributes
 
-    # Separate body and headers from the positional args
     body = nil
     headers = {}
 
@@ -126,89 +144,74 @@ module OnyxCord::API
       end
     end
 
-    # Extract content_type from headers for HTTPX
     content_type = headers.delete(:content_type)
     headers['content-type'] = 'application/json' if content_type == :json
 
-    # Add user agent
     headers['user-agent'] = user_agent
 
+    retries = 0
+    max_retries = key == :gateway ? 0 : 3
+
     begin
-      rate_limiter.before_request(key, major_parameter)
+      async_rate_limiter.before_request(key, major_parameter)
 
       response = nil
-      begin
+      loop do
         response = OnyxCord::HTTP.request(type, url, body, **headers)
+        break unless response.code == 502
 
-        if response.code == 403
-          noprm = OnyxCord::Errors::NoPermission.new
-          noprm.define_singleton_method(:_response) { response }
-          raise noprm, "The bot doesn't have the required permission to do this!"
-        end
+        retries += 1
+        break unless retries < max_retries
 
-        # Retry on 502
-        if response.code == 502
-          OnyxCord::LOGGER.warn('Got a 502 while sending a request! Not a big deal, retrying the request')
-          return request(key, major_parameter, type, url, body, headers)
-        end
-
-        # Handle error status codes
-        if response.code >= 400 && response.code != 429
-          data = begin
-            JSON.parse(response.body)
-          rescue StandardError
-            nil
-          end
+        OnyxCord::LOGGER.warn('Got a 502 while sending a request! Not a big deal, retrying the request')
+        OnyxCord::AsyncRuntime.sleep(retries * 0.5)
+      end
 
-          raise "HTTP #{response.code}: #{response.body}" unless data
+      if response.code == 403
+        noprm = OnyxCord::Errors::NoPermission.new
+        noprm.define_singleton_method(:_response) { response }
+        raise noprm, "The bot doesn't have the required permission to do this!"
+      end
 
-          err_klass = OnyxCord::Errors.error_class_for(data['code'] || 0)
-          e = err_klass.new(data['message'], data['errors'])
-          OnyxCord::LOGGER.error(e.full_message)
-          raise e
-        end
-      rescue OnyxCord::Errors::NoPermission => e
-        if e.respond_to?(:_response)
-          response = e._response
-        else
-          OnyxCord::LOGGER.warn("NoPermission doesn't respond_to? _response!")
+      if response.code >= 400 && response.code != 429
+        data = begin
+          JSON.parse(response.body)
+        rescue StandardError
+          nil
         end
 
+        raise "HTTP #{response.code}: #{response.body}" unless data
+
+        err_klass = OnyxCord::Errors.error_class_for(data['code'] || 0)
+        e = err_klass.new(data['message'], data['errors'])
+        OnyxCord::LOGGER.error(e.full_message)
         raise e
-      ensure
-        if response
-          rate_limiter.record_response(key, major_parameter, response.headers)
-        else
-          OnyxCord::LOGGER.ratelimit('Response was nil before trying to preemptively rate limit!')
-        end
       end
-    rescue OnyxCord::Errors::CodeError => e
-      raise if e.respond_to?(:code) && e.code != 429_000
-
-      raise
+    rescue OnyxCord::Errors::NoPermission => e
+      async_rate_limiter.record_response(key, major_parameter, e._response.headers) if e.respond_to?(:_response)
+      raise e
+    else
+      async_rate_limiter.record_response(key, major_parameter, response.headers)
     end
 
-    # Handle 429 rate limiting
-    if response&.code == 429
+    if response.code == 429
       trace("429 #{key} #{major_parameter}")
-      rate_limiter.handle_rate_limit(key, major_parameter, response)
-      return request(key, major_parameter, type, url, body, headers)
+      async_rate_limiter.handle_rate_limit(key, major_parameter, response)
+      return request_async(key, major_parameter, type, url, body, headers)
     end
 
-    # Endpoints that use Elasticsearch can return a 202 when the index isn't ready yet. Wait the
-    # amount of time indicated by the response body, and then recursively retry and return the request.
-    if response&.code == 202 && response&.body
+    if response.code == 202 && response.body
       body_data = JSON.parse(response.body)
 
       if body_data['code'] == 110_000
         case body_data['retry_after']
         when 0, 1, nil
-          sleep(rand(4.5..5.0))
+          OnyxCord::AsyncRuntime.sleep(rand(4.5..5.0))
         else
-          sleep(body_data['retry_after'])
+          OnyxCord::AsyncRuntime.sleep(body_data['retry_after'])
         end
 
-        return request(key, major_parameter, type, url, body, headers)
+        return request_async(key, major_parameter, type, url, body, headers)
       end
     end
 

data/lib/onyxcord/bot.rb

@@ -33,6 +33,7 @@ require 'onyxcord/api/invite'
 require 'onyxcord/api/interaction'
 require 'onyxcord/api/application'
 
+require 'onyxcord/async/runtime'
 require 'onyxcord/errors'
 require 'onyxcord/message_components'
 require 'onyxcord/data'
@@ -42,6 +43,7 @@ require 'onyxcord/websocket'
 require 'onyxcord/cache'
 require 'onyxcord/gateway'
 
+require 'onyxcord/application_commands'
 require 'onyxcord/voice/voice_bot'
 
 module OnyxCord
@@ -309,28 +311,27 @@ module OnyxCord
     #   this. If you need a way to safely run code after the bot is fully
     #   connected, use a {#ready} event handler instead.
     def run(background = false)
-      @gateway.run_async
-      return if background
+      if background
+        @run_task = OnyxCord::AsyncRuntime.async { run_forever }
+        return @run_task
+      end
+
+      OnyxCord::AsyncRuntime.run { run_forever }
+    end
 
-      debug('Oh wait! Not exiting yet as run was run synchronously.')
-      @gateway.sync
+    def run_forever
+      @gateway.run
     end
 
-    # Joins the bot's connection thread with the current thread.
-    # This blocks execution until the websocket stops, which should only happen
-    # manually triggered. or due to an error. This is necessary to have a
-    # continuously running bot.
     def join
-      @gateway.sync
+      @run_task&.wait
     end
     alias_method :sync, :join
 
-    # Stops the bot gracefully, disconnecting the websocket without immediately killing the thread. This means that
-    # Discord is immediately aware of the closed connection and makes the bot appear offline instantly.
-    # @note This method no longer takes an argument as of 3.4.0
     def stop(_no_sync = nil)
       @gateway.stop
       @event_executor.shutdown
+      @run_task&.stop if @run_task.respond_to?(:stop)
       nil
     end
 
@@ -411,7 +412,7 @@ module OnyxCord
 
       debug('Voice channel init packet sent! Now waiting.')
 
-      sleep(0.05) until @voices[server_id]
+      OnyxCord::AsyncRuntime.sleep(0.05) until @voices[server_id]
       debug('Voice connect succeeded!')
       @voices[server_id]
     end
@@ -477,9 +478,9 @@ module OnyxCord
     # @param enforce_nonce [true, false] Whether the nonce should be enforced and used for message de-duplication.
     # @param poll [Hash, Poll::Builder, Poll, nil] The poll that should be attached to this message.
     def send_temporary_message(channel, content, timeout, tts = false, embeds = nil, attachments = nil, allowed_mentions = nil, message_reference = nil, components = nil, flags = 0, nonce = nil, enforce_nonce = false, poll = nil)
-      Async do
+      OnyxCord::AsyncRuntime.async do
         message = send_message(channel, content, tts, embeds, attachments, allowed_mentions, message_reference, components, flags, nonce, enforce_nonce, poll)
-        sleep(timeout)
+        OnyxCord::AsyncRuntime.sleep(timeout)
         message.delete
       end
 
@@ -864,6 +865,37 @@ module OnyxCord
       ApplicationCommand.new(JSON.parse(resp), self, server_id)
     end
 
+    # @return [OnyxCord::ApplicationCommands::Registry]
+    def commands
+      @modern_command_registry ||= OnyxCord::ApplicationCommands::Registry.new(self)
+    end
+
+    def slash(name, description: nil, **attributes, &block)
+      commands.slash(name, description: description, **attributes, &block)
+    end
+
+    def user_command(name, **attributes, &block)
+      commands.user(name, **attributes, &block)
+    end
+
+    def message_command(name, **attributes, &block)
+      commands.message(name, **attributes, &block)
+    end
+
+    def sync_application_commands!(server_id: nil, delete_unknown: false)
+      commands.sync!(server_id: server_id, delete_unknown: delete_unknown)
+    end
+
+    def bulk_overwrite_global_application_commands(commands)
+      response = API::Application.bulk_overwrite_global_commands(@token, profile.id, commands)
+      JSON.parse(response).map { |data| ApplicationCommand.new(data, self) }
+    end
+
+    def bulk_overwrite_guild_application_commands(server_id, commands)
+      response = API::Application.bulk_overwrite_guild_commands(@token, profile.id, server_id.resolve_id, commands)
+      JSON.parse(response).map { |data| ApplicationCommand.new(data, self, server_id) }
+    end
+
     # @yieldparam [OptionBuilder]
     # @yieldparam [PermissionBuilder]
     # @example

data/lib/onyxcord/data/interaction.rb

@@ -299,6 +299,10 @@ module OnyxCord
       Interactions::Message.new(JSON.parse(resp), @bot, self)
     end
 
+    alias edit_original edit_response
+    alias delete_original delete_response
+    alias followup send_message
+
     # @param message [String, Integer, InteractionMessage, Message] The message created by this interaction to be edited.
     # @param content [String] The message content.
     # @param embeds [Array<Hash, Webhooks::Embed>] The embeds for the message.

data/lib/onyxcord/event_executor.rb

@@ -1,13 +1,11 @@
 # frozen_string_literal: true
 
-require 'async'
+require 'onyxcord/async/runtime'
 
 module OnyxCord
-  # Event execution strategies used by bot dispatch.
   module EventExecutor
     STOP = Object.new.freeze
 
-    # Deterministic executor useful for tests, benchmarks, and tiny bots.
     class Inline
       def post
         yield
@@ -20,8 +18,6 @@ module OnyxCord
       end
     end
 
-    # Async-based worker pool for event handlers.
-    # Uses Async tasks (fibers) instead of threads for lightweight concurrency.
     class Pool
       attr_reader :queue
 
@@ -47,7 +43,6 @@ module OnyxCord
         @queue.size
       end
 
-      # Compatibility with code that checks worker threads.
       def threads
         @workers
       end
@@ -87,6 +82,59 @@ module OnyxCord
       end
     end
 
+    class AsyncPool
+      attr_reader :queue
+
+      def initialize(size:, queue_size: nil)
+        raise ArgumentError, 'Pool size must be greater than zero' unless size.positive?
+
+        @size = size
+        @queue = ::Async::Queue.new
+        @closed = false
+        @workers = []
+        start_workers
+      end
+
+      def post(&block)
+        raise ArgumentError, 'EventExecutor::AsyncPool#post requires a block' unless block
+        raise 'Event executor has been shut down' if @closed
+
+        @queue.enqueue(block)
+      end
+
+      def queue_size
+        @queue.size
+      end
+
+      def shutdown
+        return if @closed
+
+        @closed = true
+        @size.times { @queue.enqueue(STOP) }
+      end
+
+      def threads
+        []
+      end
+
+      private
+
+      def start_workers
+        @workers = Array.new(@size) do
+          OnyxCord::AsyncRuntime.async do
+            loop do
+              job = @queue.dequeue
+              break if job.equal?(STOP)
+
+              job.call
+            rescue StandardError => e
+              OnyxCord::LOGGER.log_exception(e) if defined?(OnyxCord::LOGGER)
+            end
+          end
+        end
+      end
+    end
+
     module_function
 
     def build(type, workers:, queue_size: nil)
@@ -95,6 +143,8 @@ module OnyxCord
         Inline.new
       when :pool
         Pool.new(size: workers, queue_size: queue_size)
+      when :async_pool
+        AsyncPool.new(size: workers, queue_size: queue_size)
       else
         raise ArgumentError, "Unknown event executor: #{type.inspect}"
       end

data/lib/onyxcord/gateway.rb

@@ -3,6 +3,7 @@
 require 'async'
 require 'async/http/endpoint'
 require 'async/websocket/client'
+require 'onyxcord/async/runtime'
 require 'onyxcord/rate_limiter/gateway'
 
 module OnyxCord
@@ -86,25 +87,24 @@ module OnyxCord
 
     # Connect to the gateway server inside an Async reactor.
     def run_async
-      @ws_thread = Thread.new do
-        Thread.current[:onyxcord_name] = 'gateway'
-        Async do |task|
-          @reactor_task = task
-          connect_loop
-          LOGGER.warn('The gateway loop exited!')
-        end
-      end
+      @task = OnyxCord::AsyncRuntime.async { run }
 
-      LOGGER.debug('Gateway thread created! Waiting for confirmation...')
+      LOGGER.debug('Gateway task created! Waiting for confirmation...')
       loop do
-        sleep(0.5)
+        OnyxCord::AsyncRuntime.sleep(0.5)
         break if @ws_success
         break if @should_reconnect == false
       end
     end
 
+    def run
+      @reactor_task = Async::Task.current
+      connect_loop
+      LOGGER.warn('The gateway loop exited!')
+    end
+
     def sync
-      @ws_thread&.join
+      @task&.wait
     end
 
     def open?
@@ -118,7 +118,7 @@ module OnyxCord
     end
 
     def kill
-      @ws_thread&.kill
+      @task&.stop
     end
 
     def notify_ready
@@ -224,7 +224,7 @@ module OnyxCord
       @heartbeat_task = @reactor_task&.async do
         loop do
           if (@session && !@session.suspended?) || !@session
-            sleep @heartbeat_interval
+            OnyxCord::AsyncRuntime.sleep(@heartbeat_interval)
             if !@closed && @connection
               @bot.raise_heartbeat_event
               heartbeat
@@ -232,7 +232,7 @@ module OnyxCord
               LOGGER.debug('Tried to heartbeat without connection — skipping.')
             end
           else
-            sleep 1
+            OnyxCord::AsyncRuntime.sleep(1)
           end
         rescue StandardError => e
           LOGGER.error('Error while heartbeating!')
@@ -260,7 +260,7 @@ module OnyxCord
 
     def wait_for_reconnect
       LOGGER.debug("Reconnecting in #{@falloff} seconds.")
-      sleep @falloff
+      OnyxCord::AsyncRuntime.sleep(@falloff)
       @falloff *= 1.5
       @falloff = 115 + (rand * 10) if @falloff > 120
     end

data/lib/onyxcord/http.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require 'httpx'
+require 'onyxcord/json'
+
+module OnyxCord
+  # Modern HTTP adapter wrapping HTTPX with persistent connections, automatic
+  # retries on 502, and a response interface compatible with the rest of OnyxCord.
+  module HTTP
+    # Lightweight response wrapper so call-sites that relied on RestClient's
+    # `.body`, `.headers`, `.code` interface keep working unchanged.
+    class Response
+      # @return [String] the response body
+      attr_reader :body
+
+      # @return [Integer] the HTTP status code
+      attr_reader :code
+
+      # @return [Hash] the response headers (symbol keys, underscored)
+      attr_reader :headers
+
+      def initialize(httpx_response)
+        @raw = httpx_response
+        @body = httpx_response.body.to_s
+        @code = httpx_response.status
+        @headers = normalize_headers(httpx_response.headers)
+      end
+
+      def to_s
+        @body
+      end
+
+      # RestClient compatibility — some code calls `response` directly as a
+      # string (implicit to_s).
+      alias_method :to_str, :to_s
+
+      private
+
+      def normalize_headers(headers)
+        headers.to_h.transform_keys do |key|
+          key.to_s.tr('-', '_').downcase.to_sym
+        end
+      end
+    end
+
+    module_function
+
+    # The shared HTTPX session with persistent connections.
+    def session
+      @session ||= HTTPX.plugin(:persistent)
+                        .plugin(:follow_redirects)
+    end
+
+    # Reset the HTTP session (useful for tests).
+    def reset!
+      @session = nil
+    end
+
+    # Perform a raw HTTP request and return a {Response}.
+    # @param type [Symbol] HTTP method (:get, :post, :put, :patch, :delete)
+    # @param url [String] The full URL.
+    # @param body [String, Hash, nil] The request body.
+    # @param headers [Hash] Request headers.
+    # @return [Response]
+    def request(type, url, body = nil, **headers)
+      http = session.with(headers: headers)
+
+      raw = case type
+            when :get
+              http.get(url)
+            when :post
+              if body.is_a?(Hash) && body.any? { |_, v| v.respond_to?(:read) || v.respond_to?(:path) }
+                # Multipart upload
+                http.plugin(:multipart).post(url, form: body)
+              else
+                http.post(url, body: body)
+              end
+            when :put
+              http.put(url, body: body)
+            when :patch
+              http.patch(url, body: body)
+            when :delete
+              http.delete(url)
+            else
+              raise ArgumentError, "Unknown HTTP method: #{type}"
+            end
+
+      # HTTPX returns an error response object on network failures
+      raise raw.error if raw.is_a?(HTTPX::ErrorResponse)
+
+      Response.new(raw)
+    end
+
+    # Convenience wrappers
+    def get(url, **headers)
+      request(:get, url, nil, **headers)
+    end
+
+    def post(url, body = nil, **headers)
+      request(:post, url, body, **headers)
+    end
+
+    def put(url, body = nil, **headers)
+      request(:put, url, body, **headers)
+    end
+
+    def patch(url, body = nil, **headers)
+      request(:patch, url, body, **headers)
+    end
+
+    def delete(url, **headers)
+      request(:delete, url, nil, **headers)
+    end
+  end
+end

data/lib/onyxcord/json.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'oj'
+
+# Configure Oj in compat mode so that all stdlib JSON.parse / .to_json calls
+# are transparently accelerated. This is loaded early by the main onyxcord.rb
+# entry point so every module benefits automatically.
+module OnyxCord
+  # Fast Oj-backed JSON wrapper providing compatibility with stdlib JSON methods.
+  module JSON
+    Oj.default_options = { mode: :compat, symbol_keys: false }
+
+    module_function
+
+    # Fast JSON decode using Oj via stdlib JSON compatibility.
+    # @param data [String] The JSON string to decode.
+    # @return [Hash, Array, String, Numeric, nil]
+    def decode(data, *args)
+      ::JSON.parse(data, *args)
+    end
+
+    # Fast JSON encode using Oj via stdlib JSON compatibility.
+    # @param data [Object] The object to encode as JSON.
+    # @return [String]
+    def encode(data, *args)
+      ::JSON.generate(data, *args)
+    end
+
+    # Alias parse to decode for standard library compatibility
+    def parse(data, *args)
+      ::JSON.parse(data, *args)
+    end
+
+    # Alias generate to encode for standard library compatibility
+    def generate(data, *args)
+      ::JSON.generate(data, *args)
+    end
+
+    # Alias load to decode for Oj/JSON compatibility
+    def load(data, *args)
+      ::JSON.parse(data, *args)
+    end
+
+    # Alias dump to encode for Oj/JSON compatibility
+    def dump(data, *args)
+      ::JSON.generate(data, *args)
+    end
+  end
+end

data/lib/onyxcord/version.rb

@@ -3,5 +3,5 @@
 # OnyxCord and all its functionality, in this case only the version.
 module OnyxCord
   # The current version of onyxcord.
-  VERSION = '2.0.0'
+  VERSION = '2.0.5'
 end

data/lib/onyxcord/websocket.rb

@@ -1,25 +1,15 @@
 # frozen_string_literal: true
 
-require 'async'
+require 'onyxcord/async/runtime'
 require 'async/http/endpoint'
 require 'async/websocket/client'
 
 module OnyxCord
-  # Wrapper around async-websocket that provides the same callback-based
-  # interface used by the Gateway and Voice subsystems. This replaces the
-  # previous websocket-client-simple implementation.
   class WebSocket
-    # @return [Boolean] whether the connection is currently open.
     attr_reader :connected
 
     alias_method :connected?, :connected
 
-    # Creates a new WebSocket wrapper.
-    # @param host [String]            The `wss://` endpoint URL to connect to.
-    # @param open_handler [Proc]      Called once the connection is established.
-    # @param message_handler [Proc]   Called for every text frame received.
-    # @param error_handler [Proc]     Called when an error occurs.
-    # @param close_handler [Proc]     Called when the connection closes.
     def initialize(host, open_handler, message_handler, error_handler, close_handler)
       @host = host
       @open_handler = open_handler
@@ -33,8 +23,6 @@ module OnyxCord
       connect
     end
 
-    # Send a text message over the WebSocket.
-    # @param data [String, Hash] Data to send. Hashes are JSON-encoded automatically.
     def send(data)
       return unless @connection
 
@@ -45,7 +33,6 @@ module OnyxCord
       @error_handler&.call(e)
     end
 
-    # Cleanly close the connection.
     def close
       @connected = false
       @connection&.close
@@ -58,7 +45,7 @@ module OnyxCord
     def connect
       endpoint = Async::HTTP::Endpoint.parse(@host)
 
-      Async do
+      @task = OnyxCord::AsyncRuntime.async do
         Async::WebSocket::Client.connect(endpoint) do |connection|
           @connection = connection
           @connected = true

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: onyxcord
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.0.5
 platform: ruby
 authors:
 - Gustavo Silva
@@ -365,9 +365,6 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".devcontainer/Dockerfile"
-- ".devcontainer/devcontainer.json"
-- ".devcontainer/postcreate.sh"
 - ".github/CONTRIBUTING.md"
 - ".github/ISSUE_TEMPLATE/bug_report.md"
 - ".github/ISSUE_TEMPLATE/feature_request.md"
@@ -474,7 +471,9 @@ files:
 - lib/onyxcord/events/voice_state_update.rb
 - lib/onyxcord/events/webhooks.rb
 - lib/onyxcord/gateway.rb
+- lib/onyxcord/http.rb
 - lib/onyxcord/id_object.rb
+- lib/onyxcord/json.rb
 - lib/onyxcord/light.rb
 - lib/onyxcord/light/data.rb
 - lib/onyxcord/light/integrations.rb

data/.devcontainer/Dockerfile

@@ -1,13 +0,0 @@
-# Which Ruby version to use. You may need to use a more restrictive version,
-# e.g. `3.0`
-ARG VARIANT=3.3
-
-# Pull Microsoft's ruby devcontainer base image
-FROM mcr.microsoft.com/devcontainers/ruby:${VARIANT}
-
-# Install libsodium dependency for voice channel interactions
-RUN apt update -yq && apt install -y libsodium-dev
-
-# Ensure we're running the latest bundler, as what ships with the Ruby image may
-# not be current, and bundler will auto-downgrade to match the Gemfile.lock
-RUN gem install bundler

data/.devcontainer/devcontainer.json

@@ -1,29 +0,0 @@
-{
-  "name": "Ruby",
-  "build": {
-    "dockerfile": "Dockerfile"
-  },
-
-  // Configure tool-specific properties.
-  "customizations": {
-    // Configure properties specific to VS Code.
-    "vscode": {
-      // Add the IDs of extensions you want installed when the container is created.
-      "extensions": [
-        "shopify.ruby-lsp"
-      ]
-    }
-  },
-
-  // Set the environment variables
-  // "runArgs": ["--env-file",".env"],
-
-  // Use 'forwardPorts' to make a list of ports inside the container available locally.
-  //   "forwardPorts": [],
-
-  // Use 'postCreateCommand' to run commands after the container is created.
-  "postCreateCommand": "bash .devcontainer/postcreate.sh",
-
-  // Set `remoteUser` to `root` to connect as root instead. More info: https://aka.ms/vscode-remote/containers/non-root.
-  "remoteUser": "vscode"
-}

data/.devcontainer/postcreate.sh

@@ -1,4 +0,0 @@
-#!/bin/bash
-
-bundle config set path vendor/bundle
-bundle install --jobs=1