bolt_rb 0.3.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 52fe93311b8c4ca74313bcd5576954cdca034b6aa08c567e4a787a0c9811a3f8
-  data.tar.gz: 9baa07f42f2ff72fc7f5a876b4ec1bef04e34074defe5fcd944ca075b7d7f44d
+  metadata.gz: c4a88c6dfe625ec417db209cf02d879226ca184d5e4dbbc7c69525e8a2ed1b11
+  data.tar.gz: 55e054a4575b2f4831d00b9e15154e3e140a6dc13f433e756cc06d5308dd0780
 SHA512:
-  metadata.gz: a9157156be2d39fa0a3d98adef903c13bdb9b030fee4589f776a6b8254ca3d4fa65701edaa5f9a58bb561134148f964e39d0fa2e7fe790052f25035b6546949f
-  data.tar.gz: edd9ee321276795d73a96f40a86e2807bd48bb5e3fc012445b19b5c9885e836d501fc4a8969c4b68464e921cf5ac0f2236d9ad0ed6d579e98572070f4d1eb1bc
+  metadata.gz: 70e1cd7cbb16cebd74676223ac38e7b5035b61df1d845126c2a23220b453d3e5b1ae443fd6d903f795f637d2887d46457350cc0986176b0cf95a2a5171f16aa4
+  data.tar.gz: 3ebc0503aedba7d0d2ee617b40cabc491b2b22f0fc92d199ecdf99de18e82b2b08d924b1716e1cb7a116c02eb8d3fc9217e4c872111aefdd53b27e58c6731c4f

data/README.md

@@ -46,6 +46,14 @@ app.start
 | `bot_token` | Your Slack bot token (`xoxb-...`) |
 | `app_token` | Your Slack app-level token (`xapp-...`) for Socket Mode |
 | `handler_paths` | Array of directories to load handlers from |
+| `worker_threads` | Number of threads that run handlers. Default `5`. |
+| `assistant_thread_context_store` | Store for AI assistant thread context. Default is in-process memory. |
+
+### Concurrency
+
+Handlers run on a pool of worker threads, not on the Socket Mode reader thread. A handler that waits on a slow API call does not block pings or later events. Raise `worker_threads` if many events wait in the queue. Lower it to `1` if your handlers share state that is not thread safe.
+
+On shutdown the app stops reading new events, finishes the handlers already in progress, and then exits.
 
 ## Handlers
 
@@ -189,6 +197,62 @@ end
 
 **Available methods:** `view`, `callback_id`, `private_metadata`, `is_cleared?`, `user_id`, `ack`, `client`
 
+### AI Assistants
+
+Build an [AI app](https://docs.slack.dev/ai/agents) that lives in the Slack assistant panel. One handler class receives the full thread lifecycle:
+
+```ruby
+class SupportAssistant < BoltRb::AssistantHandler
+  # Slack opened a new assistant thread
+  def thread_started
+    say "Hi <@#{user}>! How can I help?"
+    set_suggested_prompts(
+      ['Summarize this channel', { title: 'Open tickets', message: 'List my open tickets' }],
+      title: 'Try one of these'
+    )
+  end
+
+  # The user moved to a different channel while the thread stayed open
+  def context_changed
+    # Optional. The new context is already saved for you.
+  end
+
+  # The user sent a message in the thread
+  def user_message
+    set_status 'is thinking...'
+    set_title text[0, 50]
+
+    channel_in_view = thread_context&.dig('channel_id')
+    say "You asked about <##{channel_in_view}>: #{text}"
+  end
+end
+```
+
+`thread_started` and `user_message` are required. `context_changed` is optional.
+
+`say` posts into the assistant thread. `set_status`, `set_title`, and `set_suggested_prompts` call the `assistant.threads.*` API methods for the current thread.
+
+**Thread context.** Slack sends the user's active channel with `assistant_thread_started` and `assistant_thread_context_changed`. The handler saves that context, so `thread_context` returns it during later user messages. The default store lives in process memory. Set your own store to share it across processes:
+
+```ruby
+BoltRb.configure do |config|
+  # Any object that responds to
+  #   get(channel_id:, thread_ts:)            -> Hash or nil
+  #   save(channel_id:, thread_ts:, context:) -> void
+  config.assistant_thread_context_store = RedisThreadContextStore.new
+end
+```
+
+**Testing.** The payload factory builds all three event types:
+
+```ruby
+payload.assistant_thread_started(context: { 'channel_id' => 'C123' })
+payload.assistant_thread_context_changed(context: { 'channel_id' => 'C456' })
+payload.assistant_message(text: 'hello', thread_ts: '1700000000.000100')
+```
+
+**Available methods:** `event`, `assistant_thread`, `thread_ts`, `text`, `user`, `channel`, `thread_context`, `save_thread_context`, `say`, `set_status`, `set_title`, `set_suggested_prompts`, `client`
+
 ## Handler Methods
 
 All handlers have access to:
@@ -226,6 +290,12 @@ end
 4. Add a **Bot Token** with the scopes you need (e.g., `chat:write`, `commands`)
 5. Install the app to your workspace
 
+For AI assistants, also:
+
+1. Enable **Agents & AI Apps** under Features
+2. Add the `assistant:write`, `chat:write`, and `im:history` bot scopes
+3. Subscribe to the `assistant_thread_started`, `assistant_thread_context_changed`, and `message.im` events
+
 ## Development
 
 ```bash

data/lib/bolt_rb/app.rb

@@ -39,28 +39,37 @@ module BoltRb
     # @return [SocketMode::Client] The Socket Mode client instance
     attr_reader :socket_client
 
+    # @return [WorkerPool] The pool that runs handlers off the socket thread
+    attr_reader :worker_pool
+
     # Creates a new App instance
     #
-    # Initializes the Slack Web API client for making API calls
-    # and the Socket Mode client for receiving events.
+    # Initializes the Slack Web API client for making API calls,
+    # the worker pool for running handlers, and the Socket Mode
+    # client for receiving events.
     def initialize
       @config = BoltRb.configuration
       @router = BoltRb.router
       @client = Slack::Web::Client.new(token: config.bot_token)
+      @worker_pool = WorkerPool.new(size: config.worker_threads, logger: BoltRb.logger)
 
       setup_socket_client
     end
 
-    # Starts the Socket Mode connection
+    # Starts the worker pool and the Socket Mode connection
     #
     # Loads all handlers from configured paths and connects to Slack
-    # via Socket Mode to start receiving events.
+    # via Socket Mode to start receiving events. Blocks until the
+    # socket client stops, then drains the worker pool.
     #
     # @return [void]
     def start
       load_handlers
-      BoltRb.logger.info '[BoltRb] Starting app...'
+      BoltRb.logger.info "[BoltRb] Starting app with #{config.worker_threads} worker threads..."
+      @worker_pool.start
       @socket_client.start
+    ensure
+      @worker_pool.shutdown
     end
 
     # Stops the Socket Mode connection
@@ -128,14 +137,17 @@ module BoltRb
 
     # Handles incoming Socket Mode events
     #
-    # Extracts the payload from the Socket Mode envelope and routes it
-    # to the appropriate handlers.
+    # Extracts the payload from the Socket Mode envelope on the socket
+    # thread, then hands it to the worker pool so the socket thread can
+    # return to reading frames.
     #
     # @param data [Hash] The Socket Mode envelope data
     # @return [void]
     def handle_socket_event(data)
       payload = extract_payload(data)
-      process_event(payload) if payload
+      return unless payload
+
+      @worker_pool.post { process_event(payload) }
     rescue StandardError => e
       BoltRb.logger.error "[BoltRb] Error handling socket event: #{e.message}"
       BoltRb.logger.error e.backtrace.first(5).join("\n")

data/lib/bolt_rb/assistant/memory_thread_context_store.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module BoltRb
+  module Assistant
+    # In-memory store for assistant thread context.
+    #
+    # Slack sends the user's active channel with `assistant_thread_started`
+    # and `assistant_thread_context_changed`. This store keeps that context
+    # so later user messages in the same thread can read it.
+    #
+    # Data lives only in the current process. Give
+    # `BoltRb.configuration.assistant_thread_context_store` an object with
+    # the same `get` and `save` methods to persist across processes.
+    #
+    # @example Custom store
+    #   class RedisThreadContextStore
+    #     def get(channel_id:, thread_ts:)
+    #       json = redis.get("assistant:#{channel_id}:#{thread_ts}")
+    #       json && JSON.parse(json)
+    #     end
+    #
+    #     def save(channel_id:, thread_ts:, context:)
+    #       redis.set("assistant:#{channel_id}:#{thread_ts}", context.to_json)
+    #     end
+    #   end
+    class MemoryThreadContextStore
+      def initialize
+        @contexts = {}
+        @mutex = Mutex.new
+      end
+
+      # Read the saved context for a thread
+      #
+      # @param channel_id [String] The DM channel ID
+      # @param thread_ts [String] The thread timestamp
+      # @return [Hash, nil] The saved context or nil
+      def get(channel_id:, thread_ts:)
+        @mutex.synchronize { @contexts[key(channel_id, thread_ts)] }
+      end
+
+      # Save the context for a thread
+      #
+      # @param channel_id [String] The DM channel ID
+      # @param thread_ts [String] The thread timestamp
+      # @param context [Hash] The context to save
+      # @return [void]
+      def save(channel_id:, thread_ts:, context:)
+        @mutex.synchronize { @contexts[key(channel_id, thread_ts)] = context }
+      end
+
+      private
+
+      # Build the lookup key for a thread
+      #
+      # @return [String]
+      def key(channel_id, thread_ts)
+        "#{channel_id}:#{thread_ts}"
+      end
+    end
+  end
+end

data/lib/bolt_rb/configuration.rb

@@ -24,6 +24,11 @@ module BoltRb
     attr_accessor :bot_token, :app_token, :signing_secret,
                   :handler_paths, :logger, :error_handler
 
+    # @return [Integer] Number of threads that run handlers. Default 5.
+    attr_accessor :worker_threads
+
+    attr_writer :assistant_thread_context_store
+
     attr_reader :middleware
 
     def initialize
@@ -31,6 +36,18 @@ module BoltRb
       @logger = Logger.new($stdout)
       @logger.level = Logger::INFO
       @middleware = [BoltRb::Middleware::Logging]
+      @worker_threads = 5
+    end
+
+    # Return the store for assistant thread context
+    #
+    # Defaults to an in-process memory store. Any object that responds to
+    # `get(channel_id:, thread_ts:)` and `save(channel_id:, thread_ts:, context:)`
+    # can replace it.
+    #
+    # @return [Object] The thread context store
+    def assistant_thread_context_store
+      @assistant_thread_context_store ||= BoltRb::Assistant::MemoryThreadContextStore.new
     end
 
     # Add middleware to the stack

data/lib/bolt_rb/handlers/assistant_handler.rb

@@ -0,0 +1,232 @@
+# frozen_string_literal: true
+
+module BoltRb
+  module Handlers
+    # Handler for Slack AI assistant threads.
+    #
+    # One subclass receives the three events that make up an assistant
+    # conversation: `assistant_thread_started`,
+    # `assistant_thread_context_changed`, and threaded direct messages
+    # from the user.
+    #
+    # @example
+    #   class MyAssistant < BoltRb::AssistantHandler
+    #     def thread_started
+    #       set_suggested_prompts(['Summarize this channel'])
+    #     end
+    #
+    #     def user_message
+    #       set_status('is thinking...')
+    #       say("You said: #{text}")
+    #     end
+    #   end
+    class AssistantHandler < Base
+      THREAD_STARTED = 'assistant_thread_started'
+      CONTEXT_CHANGED = 'assistant_thread_context_changed'
+      MESSAGE = 'message'
+
+      class << self
+        # Match the assistant events and threaded user DMs
+        #
+        # @param payload [Hash] The incoming Slack event payload
+        # @return [Boolean]
+        def matches?(payload)
+          # The abstract class is auto-registered but must never run
+          return false if self == AssistantHandler
+
+          event = payload['event']
+          return false unless event
+
+          case event['type']
+          when THREAD_STARTED, CONTEXT_CHANGED then true
+          when MESSAGE then user_thread_message?(event)
+          else false
+          end
+        end
+
+        private
+
+        # Check for a human message inside a DM thread
+        #
+        # @param event [Hash] The message event
+        # @return [Boolean]
+        def user_thread_message?(event)
+          return false unless event['channel_type'] == 'im'
+          return false if event['thread_ts'].nil?
+          return false if event['bot_id']
+          return false if event['subtype']
+
+          true
+        end
+      end
+
+      # Route the event to the matching hook method
+      #
+      # @return [void]
+      def handle
+        case event['type']
+        when THREAD_STARTED
+          save_thread_context(assistant_thread['context'])
+          thread_started
+        when CONTEXT_CHANGED
+          save_thread_context(assistant_thread['context'])
+          context_changed
+        when MESSAGE
+          user_message
+        end
+      end
+
+      # Hook for a new assistant thread
+      #
+      # @raise [NotImplementedError] Subclasses must define this method
+      def thread_started
+        raise NotImplementedError, "#{self.class} must implement #thread_started"
+      end
+
+      # Hook for a change of the user's active channel
+      #
+      # The new context is saved before this runs. The default does nothing.
+      #
+      # @return [void]
+      def context_changed; end
+
+      # Hook for a user message inside the assistant thread
+      #
+      # @raise [NotImplementedError] Subclasses must define this method
+      def user_message
+        raise NotImplementedError, "#{self.class} must implement #user_message"
+      end
+
+      # Return the event portion of the payload
+      #
+      # @return [Hash] The event data
+      def event
+        payload['event']
+      end
+
+      # Return the assistant_thread object for thread events
+      #
+      # @return [Hash, nil]
+      def assistant_thread
+        event['assistant_thread']
+      end
+
+      # Return the DM channel ID of the assistant thread
+      #
+      # @return [String, nil]
+      def channel
+        assistant_thread&.dig('channel_id') || event['channel']
+      end
+
+      # Return the thread timestamp of the assistant thread
+      #
+      # @return [String, nil]
+      def thread_ts
+        assistant_thread&.dig('thread_ts') || event['thread_ts']
+      end
+
+      # Return the user ID that owns the assistant thread
+      #
+      # @return [String, nil]
+      def user
+        assistant_thread&.dig('user_id') || event['user']
+      end
+
+      # Return the message text for user messages
+      #
+      # @return [String, nil]
+      def text
+        event['text']
+      end
+
+      # Return the context of the assistant thread
+      #
+      # Thread events carry the context in the payload. User messages read
+      # it from the configured thread context store.
+      #
+      # @return [Hash, nil] Keys such as channel_id, team_id, enterprise_id
+      def thread_context
+        return assistant_thread['context'] if assistant_thread
+
+        thread_context_store.get(channel_id: channel, thread_ts: thread_ts)
+      end
+
+      # Save a context for the current thread
+      #
+      # @param context [Hash] The context to save
+      # @return [void]
+      def save_thread_context(context)
+        return if context.nil?
+
+        thread_context_store.save(channel_id: channel, thread_ts: thread_ts, context: context)
+      end
+
+      # Post a message into the assistant thread
+      #
+      # @param message [String, Hash] Text or chat.postMessage options
+      # @return [Hash] The Slack API response
+      def say(message)
+        options = message.is_a?(Hash) ? message : { text: message }
+        client.chat_postMessage(options.merge(channel: channel, thread_ts: thread_ts))
+      end
+
+      # Set the status line shown while the assistant works
+      #
+      # @param status [String] Status text, for example 'is thinking...'
+      # @return [Hash] The Slack API response
+      def set_status(status)
+        client.assistant_threads_setStatus(thread_target.merge(status: status))
+      end
+
+      # Set the title of the assistant thread
+      #
+      # @param title [String] The thread title
+      # @return [Hash] The Slack API response
+      def set_title(title)
+        client.assistant_threads_setTitle(thread_target.merge(title: title))
+      end
+
+      # Set the suggested prompts shown to the user
+      #
+      # Plain strings become prompts with the same title and message.
+      #
+      # @param prompts [Array<String, Hash>] Up to four prompts
+      # @param title [String, nil] Optional heading above the prompts
+      # @return [Hash] The Slack API response
+      def set_suggested_prompts(prompts, title: nil)
+        options = thread_target.merge(prompts: normalize_prompts(prompts))
+        options[:title] = title if title
+        client.assistant_threads_setSuggestedPrompts(options)
+      end
+
+      private
+
+      # Return the configured thread context store
+      #
+      # @return [Object]
+      def thread_context_store
+        BoltRb.configuration.assistant_thread_context_store
+      end
+
+      # Build the channel and thread arguments for assistant API calls
+      #
+      # @return [Hash]
+      def thread_target
+        { channel_id: channel, thread_ts: thread_ts }
+      end
+
+      # Convert prompt strings into title and message hashes
+      #
+      # @param prompts [Array<String, Hash>]
+      # @return [Array<Hash>]
+      def normalize_prompts(prompts)
+        prompts.map do |prompt|
+          prompt.is_a?(Hash) ? prompt : { title: prompt, message: prompt }
+        end
+      end
+    end
+  end
+
+  # Top-level alias for convenience
+  AssistantHandler = Handlers::AssistantHandler
+end

data/lib/bolt_rb/testing/payload_factory.rb

@@ -129,8 +129,72 @@ module BoltRb
           payload
         end
 
+        # Creates an assistant_thread_started event payload
+        #
+        # @param user [String] The user ID (default: 'U123TEST')
+        # @param channel [String] The DM channel ID (default: 'D456TEST')
+        # @param thread_ts [String, nil] The thread timestamp (auto-generated if nil)
+        # @param context [Hash] The thread context (default: a channel and team)
+        # @return [Hash] The assistant_thread_started payload
+        def assistant_thread_started(user: 'U123TEST', channel: 'D456TEST', thread_ts: nil, context: nil)
+          assistant_thread_event('assistant_thread_started', user, channel, thread_ts, context)
+        end
+
+        # Creates an assistant_thread_context_changed event payload
+        #
+        # @param user [String] The user ID (default: 'U123TEST')
+        # @param channel [String] The DM channel ID (default: 'D456TEST')
+        # @param thread_ts [String, nil] The thread timestamp (auto-generated if nil)
+        # @param context [Hash] The new thread context (default: a channel and team)
+        # @return [Hash] The assistant_thread_context_changed payload
+        def assistant_thread_context_changed(user: 'U123TEST', channel: 'D456TEST', thread_ts: nil,
+                                             context: nil)
+          assistant_thread_event('assistant_thread_context_changed', user, channel, thread_ts, context)
+        end
+
+        # Creates a user message inside an assistant thread
+        #
+        # @param text [String] The message text
+        # @param thread_ts [String] The assistant thread timestamp
+        # @param user [String] The user ID (default: 'U123TEST')
+        # @param channel [String] The DM channel ID (default: 'D456TEST')
+        # @return [Hash] The threaded direct message payload
+        def assistant_message(text:, thread_ts:, user: 'U123TEST', channel: 'D456TEST')
+          {
+            'type' => 'event_callback',
+            'event' => {
+              'type' => 'message',
+              'channel_type' => 'im',
+              'text' => text,
+              'user' => user,
+              'channel' => channel,
+              'ts' => generate_ts,
+              'thread_ts' => thread_ts
+            }
+          }
+        end
+
         private
 
+        # Builds an assistant thread event payload
+        #
+        # @return [Hash]
+        def assistant_thread_event(type, user, channel, thread_ts, context)
+          {
+            'type' => 'event_callback',
+            'event' => {
+              'type' => type,
+              'assistant_thread' => {
+                'user_id' => user,
+                'channel_id' => channel,
+                'thread_ts' => thread_ts || generate_ts,
+                'context' => context || { 'channel_id' => 'C456TEST', 'team_id' => 'T123TEST' }
+              },
+              'event_ts' => generate_ts
+            }
+          }
+        end
+
         # Generates a fake Slack timestamp
         #
         # @return [String] A timestamp in Slack's format (epoch.random)

data/lib/bolt_rb/testing/rspec_helpers.rb

@@ -44,6 +44,9 @@ module BoltRb
         allow(client).to receive(:chat_update).and_return({ 'ok' => true })
         allow(client).to receive(:views_open).and_return({ 'ok' => true })
         allow(client).to receive(:views_update).and_return({ 'ok' => true })
+        allow(client).to receive(:assistant_threads_setStatus).and_return({ 'ok' => true })
+        allow(client).to receive(:assistant_threads_setTitle).and_return({ 'ok' => true })
+        allow(client).to receive(:assistant_threads_setSuggestedPrompts).and_return({ 'ok' => true })
         client
       end
 

data/lib/bolt_rb/version.rb

@@ -1,4 +1,4 @@
 # lib/bolt_rb/version.rb
 module BoltRb
-  VERSION = '0.3.1'
+  VERSION = '0.5.0'
 end

data/lib/bolt_rb/worker_pool.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module BoltRb
+  # Fixed-size pool of threads that run handler jobs.
+  #
+  # The Socket Mode client reads frames on one thread. Handlers that
+  # wait on the network must not run on that thread, or pings and later
+  # events stall behind them. The App posts each event to this pool
+  # and the socket thread returns to reading at once.
+  #
+  # @example
+  #   pool = BoltRb::WorkerPool.new(size: 4, logger: BoltRb.logger)
+  #   pool.start
+  #   pool.post { do_slow_work }
+  #   pool.shutdown
+  class WorkerPool
+    # @return [Integer] Number of worker threads
+    attr_reader :size
+
+    # Creates a new pool. Call #start to spawn the threads.
+    #
+    # @param size [Integer] Number of worker threads
+    # @param logger [Logger] Logger for job errors
+    # @param shutdown_timeout [Numeric] Seconds to wait for each worker on shutdown
+    def initialize(size:, logger:, shutdown_timeout: 30)
+      @size = size
+      @logger = logger
+      @shutdown_timeout = shutdown_timeout
+      @queue = nil
+      @threads = []
+      @running = false
+    end
+
+    # Spawns the worker threads
+    #
+    # @return [void]
+    def start
+      return if @running
+
+      @queue = Queue.new
+      @running = true
+      @threads = Array.new(size) { |index| spawn_worker(index) }
+    end
+
+    # Queues a job for a worker thread
+    #
+    # If the pool is not running, the job runs on the calling thread.
+    #
+    # @yield The job to run
+    # @return [void]
+    def post(&job)
+      if @running
+        @queue << job
+      else
+        run_job(job)
+      end
+    end
+
+    # Stops accepting jobs, finishes queued jobs, and joins the workers
+    #
+    # Workers that do not finish inside the shutdown timeout are left to
+    # exit on their own. The pool reports not running either way.
+    #
+    # @return [void]
+    def shutdown
+      return unless @running
+
+      @running = false
+      @queue.close
+      @threads.each do |thread|
+        next if thread.join(@shutdown_timeout)
+
+        @logger.warn "[WorkerPool] #{thread.name} did not finish within #{@shutdown_timeout}s"
+      end
+      @threads = []
+    end
+
+    # @return [Boolean] Whether the pool accepts jobs
+    def running?
+      @running
+    end
+
+    # @return [Integer] Number of jobs waiting for a worker
+    def queue_size
+      @queue ? @queue.size : 0
+    end
+
+    private
+
+    # Creates one worker thread that drains the queue until it closes
+    #
+    # @param index [Integer] Worker number, used in the thread name
+    # @return [Thread]
+    def spawn_worker(index)
+      Thread.new do
+        Thread.current.name = "bolt-rb-worker-#{index}"
+        while (job = @queue.pop)
+          run_job(job)
+        end
+      end
+    end
+
+    # Runs one job and logs any error it raises
+    #
+    # @param job [Proc]
+    # @return [void]
+    def run_job(job)
+      job.call
+    rescue StandardError => e
+      @logger.error "[WorkerPool] Job failed: #{e.class}: #{e.message}"
+      @logger.error e.backtrace.first(5).join("\n") if e.backtrace
+    end
+  end
+end

data/lib/bolt_rb.rb

@@ -62,9 +62,11 @@ require_relative 'bolt_rb/version'
 require_relative 'bolt_rb/middleware/base'
 require_relative 'bolt_rb/middleware/chain'
 require_relative 'bolt_rb/middleware/logging'
+require_relative 'bolt_rb/assistant/memory_thread_context_store'
 require_relative 'bolt_rb/configuration'
 require_relative 'bolt_rb/context'
 require_relative 'bolt_rb/router'
+require_relative 'bolt_rb/worker_pool'
 require_relative 'bolt_rb/handlers/base'
 require_relative 'bolt_rb/handlers/event_handler'
 require_relative 'bolt_rb/handlers/command_handler'
@@ -72,6 +74,7 @@ require_relative 'bolt_rb/handlers/action_handler'
 require_relative 'bolt_rb/handlers/shortcut_handler'
 require_relative 'bolt_rb/handlers/view_submission_handler'
 require_relative 'bolt_rb/handlers/view_closed_handler'
+require_relative 'bolt_rb/handlers/assistant_handler'
 require_relative 'bolt_rb/socket_mode/client'
 require_relative 'bolt_rb/testing'
 require_relative 'bolt_rb/app'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bolt_rb
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.5.0
 platform: ruby
 authors:
 - Jon Whitcraft
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-01-29 00:00:00.000000000 Z
+date: 2026-09-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: slack-ruby-client
@@ -38,20 +38,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.9'
-- !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -106,9 +92,11 @@ files:
 - README.md
 - lib/bolt_rb.rb
 - lib/bolt_rb/app.rb
+- lib/bolt_rb/assistant/memory_thread_context_store.rb
 - lib/bolt_rb/configuration.rb
 - lib/bolt_rb/context.rb
 - lib/bolt_rb/handlers/action_handler.rb
+- lib/bolt_rb/handlers/assistant_handler.rb
 - lib/bolt_rb/handlers/base.rb
 - lib/bolt_rb/handlers/command_handler.rb
 - lib/bolt_rb/handlers/event_handler.rb
@@ -124,6 +112,7 @@ files:
 - lib/bolt_rb/testing/payload_factory.rb
 - lib/bolt_rb/testing/rspec_helpers.rb
 - lib/bolt_rb/version.rb
+- lib/bolt_rb/worker_pool.rb
 homepage: https://github.com/h2ik/bolt_rb
 licenses:
 - MIT