chat_sdk-slack 1.2.0 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 49b9759d50173e826b41f885fcba2f2c276d28574f187ac70bd1932d3da28ab4
-  data.tar.gz: 80c4806743ab979c9a6f024c5f7d8081152cdf8eaacb63607728e78518b88a5c
+  metadata.gz: 6241d4c2d31e93f23988f0454bdc618d527d03542b1fad95fdb0326024d4268c
+  data.tar.gz: 720e5ea6b813a557335e59d2c2b42c9f5194a7f2dc8dfca0c6a7e937f36cbe2c
 SHA512:
-  metadata.gz: c79dccb6431aa33e0c9aa756287b7ec4342e97d4733b42e91f94e5ecfe44267e73dd404890dc13d600700985c6d958f03acad36f52121ec62ba010eb14145019
-  data.tar.gz: cebaf0452264d3b98802a1774fd834d77fa3be5b83a9f38848890c0b8ec742f976a0e510edf520f97f06e0375ca33c5fdce5af845043381cdb8a0ba1ee3b351d
+  metadata.gz: '08bdf2fc0b16165e5de33015cf87c40aea4b5ace2934c3cf503a0488f43ba22cce49a81aaa2aa06078a4d8dc414a0be2ac958a5d9b8c4e66701ebf62048e74e6'
+  data.tar.gz: 6b33b090da4111d30602550197797a2169125caa3982e7ce22b44091b9cb5de38b4a22caf6090ca4aecf448314cb6017bcbe2115182ea67dec64c7ea2141be90

data/lib/chat_sdk/slack/adapter.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "stringio"
+
 module ChatSDK
   module Slack
     class Adapter < ChatSDK::Adapter::Base
@@ -9,38 +11,86 @@ module ChatSDK
         :scheduled_messages
 
       def initialize(bot_token: nil, signing_secret: nil,
-        client_id: nil, client_secret: nil, proxy: nil, bot_user_id: nil)
-        @bot_token = bot_token || ENV["SLACK_BOT_TOKEN"]
+        client_id: nil, client_secret: nil, proxy: nil, bot_user_id: nil,
+        installation_provider: nil, encryption_key: nil, webhook_verifier: nil,
+        native_streaming: true, stream_segment_max_age: 240)
+        @bot_token = bot_token.nil? ? ENV["SLACK_BOT_TOKEN"] : bot_token
         @signing_secret = signing_secret || ENV["SLACK_SIGNING_SECRET"]
         @client_id = client_id || ENV["SLACK_CLIENT_ID"]
         @client_secret = client_secret || ENV["SLACK_CLIENT_SECRET"]
         @bot_user_id = bot_user_id || ENV["SLACK_BOT_USER_ID"]
+        @installation_provider = installation_provider
+        @webhook_verifier = webhook_verifier
+        encryption_key ||= ENV["SLACK_ENCRYPTION_KEY"]
+        @encryption_key = TokenEncryption.decode_key(encryption_key) if encryption_key
+        valid_segment_max_age = stream_segment_max_age.is_a?(Numeric) &&
+          !stream_segment_max_age.is_a?(Complex) &&
+          !(stream_segment_max_age.respond_to?(:nan?) && stream_segment_max_age.nan?) &&
+          (stream_segment_max_age.positive? || stream_segment_max_age == Float::INFINITY)
+        unless valid_segment_max_age
+          raise ChatSDK::ConfigurationError, "stream_segment_max_age must be a positive number"
+        end
+        @native_streaming = native_streaming
+        @native_streaming_broken = false
+        @stream_segment_max_age = stream_segment_max_age
         @bot_user_ids = {}
         @bot_user_id_mutex = Mutex.new
+        @client_cache = {}
+        @client_cache_mutex = Mutex.new
+        @context_key = :"chat_sdk_slack_context_#{object_id}"
         @proxy = proxy || ENV["HTTPS_PROXY"] || ENV["https_proxy"]
 
-        unless @bot_token || @client_id
-          raise ChatSDK::ConfigurationError, "Slack bot_token or client_id required"
+        if !@bot_token.nil? && !@bot_token.is_a?(String) && !@bot_token.respond_to?(:call)
+          raise ChatSDK::ConfigurationError, "Slack bot_token must be a String or callable"
+        end
+        if !@installation_provider.nil? && !@installation_provider.respond_to?(:get_installation) && !@installation_provider.respond_to?(:call)
+          raise ChatSDK::ConfigurationError, "Slack installation_provider must respond to get_installation or call"
+        end
+        if !@webhook_verifier.nil? && !@webhook_verifier.respond_to?(:call)
+          raise ChatSDK::ConfigurationError, "Slack webhook_verifier must be callable"
+        end
+        unless @bot_token || @client_id || @installation_provider
+          raise ChatSDK::ConfigurationError, "Slack bot_token, client_id or installation_provider required"
+        end
+        if @webhook_verifier.nil? && !@signing_secret
+          raise ChatSDK::ConfigurationError, "Slack signing_secret or webhook_verifier required"
         end
-        raise ChatSDK::ConfigurationError, "Slack signing_secret required" unless @signing_secret
 
-        if @bot_token
+        if @bot_token.is_a?(String)
           ::Slack.configure do |config|
             config.token = @bot_token
           end
-          @client = build_client(token: @bot_token)
+          @client = client_for_token(@bot_token)
         end
 
         @renderer = BlockKitRenderer.new
         @modal_renderer = ModalRenderer.new
-        @team_clients = {}
       end
 
       # Returns the per-request client (multi-workspace) or the static client (single-workspace).
       def client
-        return @client unless @client_id
+        request_context = context
+        return client_for_token(request_context[:token]) if request_context && !request_context[:token].nil?
+        return @client if @bot_token.is_a?(String)
+        return unless @bot_token.respond_to?(:call)
+
+        token = @bot_token.call
+        if token.nil? || token == false || (token.respond_to?(:empty?) && token.empty?)
+          raise ChatSDK::ConfigurationError, "Slack bot_token resolver returned no token"
+        end
+        client_for_token(token)
+      end
 
-        ::Thread.current[:chat_sdk_slack_client] || @client
+      def multi_workspace?
+        @bot_token.nil? || !@client_id.nil?
+      end
+
+      def with_bot_token(token, installation_id: nil)
+        previous_context = context
+        set_context(token: token, installation_id: installation_id)
+        yield
+      ensure
+        set_context(previous_context)
       end
 
       # Inject state store after initialization (e.g., from Chat instance).
@@ -50,26 +100,38 @@ module ChatSDK
 
       # --- Multi-workspace installation management ---
 
-      def set_installation(team_id, bot_token:, bot_user_id: nil, team_name: nil)
+      def set_installation(team_id, bot_token:, bot_user_id: nil, team_name: nil,
+        enterprise_id: nil, enterprise_install: nil)
         raise ChatSDK::ConfigurationError, "Multi-workspace mode requires state" unless @state
 
-        @team_clients.delete(team_id)
-        @state.set(installation_key(team_id), {
-          "bot_token" => bot_token,
+        installation = {
+          "bot_token" => @encryption_key ? TokenEncryption.encrypt(bot_token, @encryption_key) : bot_token,
           "bot_user_id" => bot_user_id,
           "team_name" => team_name
-        })
+        }
+        installation["enterprise_id"] = enterprise_id unless enterprise_id.nil?
+        installation["is_enterprise_install"] = enterprise_install unless enterprise_install.nil?
+        @state.set(installation_key(team_id), installation)
         invalidate_bot_user_id(team_id)
       end
 
       def get_installation(team_id)
         return nil unless @state
 
-        @state.get(installation_key(team_id))
+        installation = @state.get(installation_key(team_id))
+        return installation unless installation.is_a?(Hash)
+
+        token_key = installation.key?("bot_token") ? "bot_token" : :bot_token
+        token = installation[token_key]
+        return installation unless TokenEncryption.encrypted?(token)
+        unless @encryption_key
+          raise ChatSDK::ConfigurationError, "Slack installation token is encrypted; configure encryption_key"
+        end
+
+        installation.merge(token_key => TokenEncryption.decrypt(token, @encryption_key))
       end
 
       def delete_installation(team_id)
-        @team_clients.delete(team_id)
         invalidate_bot_user_id(team_id)
         return unless @state
 
@@ -89,19 +151,39 @@ module ChatSDK
 
         result = temp_client.oauth_v2_access(**params)
 
-        team_id = result["team"]["id"]
+        team = hash_value(result, "team")
+        enterprise = hash_value(result, "enterprise")
+        enterprise_install = truthy_slack_value?(hash_value(result, "is_enterprise_install"))
+        enterprise_id = hash_value(enterprise, "id") || hash_value(result, "enterprise_id")
+        team_id = hash_value(team, "id")
+        installation_id = enterprise_install ? enterprise_id : team_id
+        access_token = hash_value(result, "access_token")
+        unless access_token && !access_token.empty? && installation_id && !installation_id.empty?
+          missing = enterprise_install ? "access_token or enterprise.id" : "access_token or team.id"
+          raise ChatSDK::ConfigurationError, "Slack OAuth response missing #{missing}"
+        end
+
         installation = {
-          "bot_token" => result["access_token"],
-          "bot_user_id" => result["bot_user_id"],
-          "team_name" => result["team"]["name"]
+          "bot_token" => access_token,
+          "bot_user_id" => hash_value(result, "bot_user_id"),
+          "team_name" => hash_value(team, "name") || hash_value(enterprise, "name")
         }
+        installation["enterprise_id"] = enterprise_id unless enterprise_id.nil?
+        installation["is_enterprise_install"] = enterprise_install if hash_key?(result, "is_enterprise_install")
 
-        set_installation(team_id,
+        set_installation(installation_id,
           bot_token: installation["bot_token"],
           bot_user_id: installation["bot_user_id"],
-          team_name: installation["team_name"])
-
-        {team_id: team_id, installation: installation}
+          team_name: installation["team_name"],
+          enterprise_id: enterprise_id,
+          enterprise_install: hash_key?(result, "is_enterprise_install") ? enterprise_install : nil)
+
+        {
+          team_id: installation_id,
+          enterprise_id: enterprise_id,
+          enterprise_install: enterprise_install,
+          installation: installation
+        }
       end
 
       def name
@@ -112,6 +194,18 @@ module ChatSDK
       def verify_request!(rack_request)
         body = rack_request.body.read
         rack_request.body.rewind
+        if @webhook_verifier
+          begin
+            result = @webhook_verifier.call(rack_request, body)
+          rescue => e
+            raise ChatSDK::SignatureVerificationError, "Slack webhook verifier failed: #{e.message}"
+          end
+          raise ChatSDK::SignatureVerificationError, "Slack webhook verifier rejected the request" unless result
+
+          rack_request.env["rack.input"] = StringIO.new(result) if result.is_a?(String)
+          return true
+        end
+
         timestamp = rack_request.env["HTTP_X_SLACK_REQUEST_TIMESTAMP"]
         signature = rack_request.env["HTTP_X_SLACK_SIGNATURE"]
 
@@ -146,19 +240,14 @@ module ChatSDK
       end
 
       def parse_events(rack_request)
+        set_context(nil)
         body = rack_request.body.read
         rack_request.body.rewind
 
         parsed = parse_body(body, rack_request.content_type)
         return [] unless parsed
 
-        # Multi-workspace: resolve per-team client from payload
-        # Clear any stale client from a previous request on this thread (Puma thread pool safety)
-        if @client_id
-          ::Thread.current[:chat_sdk_slack_client] = nil
-          team_id = parsed["team_id"] || parsed.dig("team", "id")
-          resolve_team_client(team_id) if team_id
-        end
+        return [] unless prepare_payload_context(parsed)
 
         events = EventParser.parse(parsed)
         classify_message_events(events, parsed)
@@ -185,6 +274,26 @@ module ChatSDK
         )
       end
 
+      def stream(channel_id:, thread_id:, stream:, options: {})
+        return unless thread_id && !thread_id.to_s.empty?
+        direct_message = channel_id.to_s.start_with?("D")
+        recipient_ids = [options[:recipient_user_id], options[:recipient_team_id]]
+        has_recipient_context = recipient_ids.all? { |id| id && !id.to_s.empty? }
+        return unless direct_message || has_recipient_context
+        return unless @native_streaming && !@native_streaming_broken
+
+        stream_client = client
+        NativeStream.new(
+          adapter: self,
+          client: stream_client,
+          channel_id: channel_id,
+          thread_id: thread_id,
+          stream: stream,
+          options: options,
+          max_age: @stream_segment_max_age
+        ).run
+      end
+
       def edit_message(channel_id:, message_id:, message:, **_options)
         msg = ChatSDK::PostableMessage.from(message)
         params = {channel: channel_id, ts: message_id}
@@ -331,13 +440,16 @@ module ChatSDK
       end
 
       def concurrency_scope(event)
-        return unless @client_id
+        return context[:installation_id] if context && context[:installation_id]
+        return unless multi_workspace?
 
         raw = event.raw.is_a?(Hash) ? event.raw : {}
         raw_event = raw.is_a?(Hash) ? raw["event"] || raw[:event] || raw : {}
         raw_team = raw.is_a?(Hash) ? raw["team"] || raw[:team] : nil
         raw_team_id = raw_team.is_a?(Hash) ? raw_team["id"] || raw_team[:id] : raw_team
-        raw_team_id || raw["team_id"] || raw[:team_id] || raw_event["team_id"] || raw_event[:team_id] || raw_event["team"] || raw_event[:team]
+        raw_team_id || raw["team_id"] || raw[:team_id] ||
+          raw_event["team_id"] || raw_event[:team_id] ||
+          raw_event["team"] || raw_event[:team]
       end
 
       # Slack-specific: receive real-time events via Socket Mode WebSocket.
@@ -354,13 +466,12 @@ module ChatSDK
         raise ArgumentError, "start requires a block" unless block
 
         @socket_mode = SocketMode.new(app_token: app_token, bot_client: client)
-        @socket_mode.start do |event|
-          if @client_id
-            ::Thread.current[:chat_sdk_slack_client] = nil
-            team_id = concurrency_scope(event)
-            resolve_team_client(team_id) if team_id
-          end
-          classify_message_events([event], event.raw)
+        @socket_mode.start do |event, payload|
+          payload ||= event.raw
+          set_context(nil)
+          next unless prepare_payload_context(payload)
+
+          classify_message_events([event], payload)
           block.call(event)
         end
       end
@@ -383,9 +494,13 @@ module ChatSDK
 
       private
 
+      def monotonic_now
+        Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      end
+
       def build_client(token: nil)
         options = {}
-        options[:token] = token if token
+        options[:token] = token unless token.nil?
         options[:proxy] = @proxy if @proxy
         options.empty? ? ::Slack::Web::Client.new : ::Slack::Web::Client.new(options)
       end
@@ -414,23 +529,24 @@ module ChatSDK
       end
 
       def resolve_bot_user_id(event)
-        team_id = concurrency_scope(event) if @client_id
-        if @client_id
-          installation = get_installation(team_id) if team_id
-          return installation["bot_user_id"] if installation && installation["bot_user_id"]
-        end
+        request_context = context
+        return request_context[:bot_user_id] if request_context && request_context[:bot_user_id]
 
         return @bot_user_id if @bot_user_id
 
-        current_client = if @client_id
-          resolve_team_client(team_id) if team_id
-        else
-          @client
+        installation_id = if multi_workspace?
+          request_context&.[](:installation_id) || event_installation_id(event)
         end
+        installation = resolve_installation(installation_id, enterprise_install: installation_enterprise_flag(event)) if installation_id && !request_context
+        installation_bot_user_id = hash_value(installation, "bot_user_id")
+        return installation_bot_user_id if installation_bot_user_id
+
+        token = request_context&.[](:token) || hash_value(installation, "bot_token")
+        current_client = token ? client_for_token(token) : client
         return unless current_client
 
         @bot_user_id_mutex.synchronize do
-          cache_key = @client_id ? (team_id || :default) : :default
+          cache_key = multi_workspace? ? (installation_id || :default) : :default
           return @bot_user_ids[cache_key] if @bot_user_ids.key?(cache_key)
 
           bot_user_id = begin
@@ -460,22 +576,142 @@ module ChatSDK
         Array(element["elements"]).any? { |child| rich_text_element_mentions_bot?(child, bot_user_id) }
       end
 
-      def resolve_team_client(team_id)
-        return unless @client_id && @state
+      def client_for_token(token)
+        @client_cache_mutex.synchronize do
+          return @client_cache[token] if @client_cache.key?(token)
+
+          @client_cache[token] = build_client(token: token)
+          @client_cache.shift while @client_cache.size > 256
+          @client_cache[token]
+        end
+      end
+
+      def context
+        ::Thread.current[@context_key]
+      end
+
+      def set_context(value)
+        ::Thread.current[@context_key] = value
+      end
 
-        cached = @team_clients[team_id]
-        if cached
-          ::Thread.current[:chat_sdk_slack_client] = cached
-          return cached
+      def prepare_payload_context(payload)
+        return true unless multi_workspace?
+
+        identity = extract_installation(payload)
+        return true unless identity
+
+        installation = resolve_installation(
+          identity[:installation_id],
+          enterprise_install: identity[:enterprise_install]
+        )
+        token = hash_value(installation, "bot_token")
+        unless installation && token && token != false && !(token.respond_to?(:empty?) && token.empty?)
+          return true unless @bot_token.nil?
+
+          ChatSDK::Log.warn("Dropping Slack event without a resolved installation for #{identity[:installation_id]}")
+          return false
         end
 
-        installation = get_installation(team_id)
-        return unless installation
+        set_context({
+          token: token,
+          bot_user_id: hash_value(installation, "bot_user_id"),
+          installation_id: identity[:installation_id],
+          enterprise_install: identity[:enterprise_install],
+          team_id: identity[:team_id],
+          enterprise_id: identity[:enterprise_id]
+        })
+        true
+      end
+
+      def resolve_installation(installation_id, enterprise_install:)
+        return unless installation_id
+
+        installation = if @installation_provider
+          if @installation_provider.respond_to?(:get_installation)
+            @installation_provider.get_installation(installation_id, enterprise_install: enterprise_install)
+          else
+            @installation_provider.call(installation_id, enterprise_install: enterprise_install)
+          end
+        else
+          get_installation(installation_id)
+        end
+        unless installation
+          ChatSDK::Log.warn("Slack installation not found for #{installation_id}")
+          return
+        end
+        token = hash_value(installation, "bot_token")
+        unless installation.is_a?(Hash) && token && token != false && !(token.respond_to?(:empty?) && token.empty?)
+          ChatSDK::Log.warn("Slack installation for #{installation_id} has no bot_token")
+          return
+        end
+
+        installation
+      rescue => e
+        ChatSDK::Log.error("Could not resolve Slack installation #{installation_id}: #{e.message}")
+        nil
+      end
+
+      def extract_installation(payload)
+        return unless payload.is_a?(Hash)
+
+        if hash_value(payload, "type") == "event_callback"
+          authorization = Array(hash_value(payload, "authorizations")).first
+          enterprise_flag = if hash_key?(authorization, "is_enterprise_install")
+            hash_value(authorization, "is_enterprise_install")
+          else
+            hash_value(payload, "is_enterprise_install")
+          end
+          enterprise_install = truthy_slack_value?(enterprise_flag)
+          team_id = hash_value(authorization, "team_id") || hash_value(payload, "team_id")
+          enterprise_id = hash_value(authorization, "enterprise_id") || hash_value(payload, "enterprise_id")
+        elsif hash_key?(payload, "command")
+          enterprise_install = hash_value(payload, "is_enterprise_install") == "true"
+          team_id = hash_value(payload, "team_id")
+          enterprise_id = hash_value(payload, "enterprise_id")
+        else
+          enterprise_install = truthy_slack_value?(hash_value(payload, "is_enterprise_install"))
+          team = hash_value(payload, "team")
+          enterprise = hash_value(payload, "enterprise")
+          team_id = hash_value(team, "id") || hash_value(payload, "team_id")
+          enterprise_id = hash_value(enterprise, "id") || hash_value(payload, "enterprise_id")
+        end
+
+        installation_id = enterprise_install ? enterprise_id : team_id
+        return unless installation_id
+
+        {
+          installation_id: installation_id,
+          enterprise_install: enterprise_install,
+          team_id: team_id,
+          enterprise_id: enterprise_id
+        }
+      end
+
+      def event_installation_id(event)
+        raw = event.raw.is_a?(Hash) ? event.raw : {}
+        extract_installation(raw)&.[](:installation_id) ||
+          hash_value(raw, "team_id") ||
+          hash_value(hash_value(raw, "team"), "id")
+      end
+
+      def installation_enterprise_flag(event)
+        raw = event.raw.is_a?(Hash) ? event.raw : {}
+        identity = extract_installation(raw)
+        identity ? identity[:enterprise_install] : truthy_slack_value?(hash_value(raw, "is_enterprise_install"))
+      end
+
+      def hash_value(hash, key)
+        return unless hash.is_a?(Hash)
+
+        hash.key?(key) ? hash[key] : hash[key.to_sym]
+      end
+
+      def hash_key?(hash, key)
+        hash.is_a?(Hash) && (hash.key?(key) || hash.key?(key.to_sym))
+      end
 
-        new_client = build_client(token: installation["bot_token"])
-        @team_clients[team_id] = new_client
-        ::Thread.current[:chat_sdk_slack_client] = new_client
-        new_client
+      def truthy_slack_value?(value)
+        value == true || value == "true"
       end
 
       def installation_key(team_id)

data/lib/chat_sdk/slack/block_kit_renderer.rb

@@ -22,6 +22,13 @@ module ChatSDK
         if node.attributes[:subtitle]
           blocks << {type: "context", elements: [{type: "mrkdwn", text: truncate_mrkdwn(node.attributes[:subtitle], 3000)}]}
         end
+        if node.attributes[:image_url] && !node.attributes[:image_url].empty?
+          blocks << {
+            type: "image",
+            image_url: node.attributes[:image_url],
+            alt_text: truncate_text(node.attributes[:title] || "Card image", 2000)
+          }
+        end
         blocks.concat(node.children.map { |child| render_node(child) }.compact)
         blocks
       end
@@ -29,6 +36,7 @@ module ChatSDK
       def render_node(node)
         case node.type
         when :text then render_text(node)
+        when :link then render_link(node)
         when :divider then {type: "divider"}
         when :image then render_image(node)
         when :fields then render_fields(node)
@@ -41,12 +49,23 @@ module ChatSDK
       end
 
       def render_text(node)
+        content = node.attributes[:content]
+        content = "*#{truncate_mrkdwn(content, 2998)}*" if node.attributes[:style] == :bold
+        return {type: "context", elements: [{type: "mrkdwn", text: truncate_mrkdwn(content, 3000)}]} if node.attributes[:style] == :muted
+
         {
           type: "section",
-          text: {type: "mrkdwn", text: truncate_mrkdwn(node.attributes[:content], 3000)}
+          text: {type: "mrkdwn", text: truncate_mrkdwn(content, 3000)}
         }
       end
 
+      def render_link(node)
+        url = node.attributes[:url]
+        label_budget = [2997 - url.to_s.length, 0].max
+        label = truncate_mrkdwn(node.attributes[:label], label_budget)
+        {type: "section", text: {type: "mrkdwn", text: "<#{url}|#{label}>"}}
+      end
+
       def render_image(node)
         block = {type: "image", image_url: node.attributes[:url]}
         block[:alt_text] = truncate_text(node.attributes[:alt] || " ", 2000)
@@ -64,9 +83,14 @@ module ChatSDK
 
       def render_section(node)
         block = {type: "section"}
-        text_children = node.children.select { |c| c.type == :text }
-        if text_children.any?
-          block[:text] = {type: "mrkdwn", text: truncate_mrkdwn(text_children.map { |t| t.attributes[:content] }.join("\n"), 3000)}
+        lines = node.children.filter_map do |child|
+          case child.type
+          when :text then child.attributes[:content]
+          when :link then render_link(child).dig(:text, :text)
+          end
+        end
+        if lines.any?
+          block[:text] = {type: "mrkdwn", text: truncate_mrkdwn(lines.join("\n"), 3000)}
         end
         block
       end
@@ -83,6 +107,7 @@ module ChatSDK
         when :button then render_button(node)
         when :link_button then render_link_button(node)
         when :select then render_select(node)
+        when :radio_select then render_radio_select(node)
         end
       end
 
@@ -109,6 +134,11 @@ module ChatSDK
           url: node.attributes[:url],
           action_id: node.attributes[:id] || "link_#{node.attributes[:url].hash.abs}"
         }
+        if node.attributes[:style] == :primary
+          button[:style] = "primary"
+        elsif node.attributes[:style] == :danger
+          button[:style] = "danger"
+        end
         button[:visible_to_user_ids] = node.attributes[:visible_to] if node.attributes[:visible_to]&.any?
         button
       end
@@ -122,9 +152,32 @@ module ChatSDK
         if node.attributes[:placeholder]
           sel[:placeholder] = {type: "plain_text", text: truncate_text(node.attributes[:placeholder], 150)}
         end
+        if node.attributes[:initial_option] && !node.attributes[:initial_option].empty?
+          initial_option = sel[:options].find { |option| option[:value] == node.attributes[:initial_option] }
+          sel[:initial_option] = initial_option if initial_option
+        end
         sel
       end
 
+      def render_radio_select(node)
+        options = node.children.first(10).map do |option|
+          rendered = {
+            text: {type: "mrkdwn", text: truncate_mrkdwn(option.attributes[:text], 75)},
+            value: option.attributes[:value]
+          }
+          if option.attributes[:description]
+            rendered[:description] = {type: "mrkdwn", text: truncate_mrkdwn(option.attributes[:description], 75)}
+          end
+          rendered
+        end
+        element = {type: "radio_buttons", action_id: node.attributes[:id], options: options}
+        if node.attributes[:initial_option] && !node.attributes[:initial_option].empty?
+          initial_option = options.find { |option| option[:value] == node.attributes[:initial_option] }
+          element[:initial_option] = initial_option if initial_option
+        end
+        element
+      end
+
       def render_option(node)
         opt = {
           text: {type: "plain_text", text: truncate_text(node.attributes[:text], 75)},