chat_sdk-slack 1.0.1 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f3267f830fd79846f929e7e61be15c2b65d1e6183f6f5d56271f88fbb6fdf85b
-  data.tar.gz: 9fe0cd67184ef4561a2e6ccb6d5678f5a639f2b53add2be5ef6436b239a1a7c3
+  metadata.gz: 49b9759d50173e826b41f885fcba2f2c276d28574f187ac70bd1932d3da28ab4
+  data.tar.gz: 80c4806743ab979c9a6f024c5f7d8081152cdf8eaacb63607728e78518b88a5c
 SHA512:
-  metadata.gz: c686e9ac2a237c82166200783289f2310cb57cc3760a4d55b11447fa0f7a746b10ffb40b713d18334f277f3efb91663733977f082cf0152ee96ed387ddbd2ed1
-  data.tar.gz: 1e897869f36b3571e31dea33be0e78f9bd46bcbc5e3c839da11453337242378933dcfec8eec289ceb4c6cbae4c339bce0a1c4399f39fe74a7980703f5e1e4c40
+  metadata.gz: c79dccb6431aa33e0c9aa756287b7ec4342e97d4733b42e91f94e5ecfe44267e73dd404890dc13d600700985c6d958f03acad36f52121ec62ba010eb14145019
+  data.tar.gz: cebaf0452264d3b98802a1774fd834d77fa3be5b83a9f38848890c0b8ec742f976a0e510edf520f97f06e0375ca33c5fdce5af845043381cdb8a0ba1ee3b351d

data/lib/chat_sdk/slack/adapter.rb

@@ -9,11 +9,15 @@ module ChatSDK
         :scheduled_messages
 
       def initialize(bot_token: nil, signing_secret: nil,
-        client_id: nil, client_secret: nil)
+        client_id: nil, client_secret: nil, proxy: nil, bot_user_id: nil)
         @bot_token = bot_token || ENV["SLACK_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"]
+        @bot_user_ids = {}
+        @bot_user_id_mutex = Mutex.new
+        @proxy = proxy || ENV["HTTPS_PROXY"] || ENV["https_proxy"]
 
         unless @bot_token || @client_id
           raise ChatSDK::ConfigurationError, "Slack bot_token or client_id required"
@@ -24,7 +28,7 @@ module ChatSDK
           ::Slack.configure do |config|
             config.token = @bot_token
           end
-          @client = ::Slack::Web::Client.new(token: @bot_token)
+          @client = build_client(token: @bot_token)
         end
 
         @renderer = BlockKitRenderer.new
@@ -34,6 +38,8 @@ module ChatSDK
 
       # Returns the per-request client (multi-workspace) or the static client (single-workspace).
       def client
+        return @client unless @client_id
+
         ::Thread.current[:chat_sdk_slack_client] || @client
       end
 
@@ -53,6 +59,7 @@ module ChatSDK
           "bot_user_id" => bot_user_id,
           "team_name" => team_name
         })
+        invalidate_bot_user_id(team_id)
       end
 
       def get_installation(team_id)
@@ -63,6 +70,7 @@ module ChatSDK
 
       def delete_installation(team_id)
         @team_clients.delete(team_id)
+        invalidate_bot_user_id(team_id)
         return unless @state
 
         @state.delete(installation_key(team_id))
@@ -71,7 +79,7 @@ module ChatSDK
       def handle_oauth_callback(code:, redirect_uri: nil)
         raise ChatSDK::ConfigurationError, "client_id required for OAuth" unless @client_id
 
-        temp_client = ::Slack::Web::Client.new
+        temp_client = build_client
         params = {
           client_id: @client_id,
           client_secret: @client_secret,
@@ -152,7 +160,8 @@ module ChatSDK
           resolve_team_client(team_id) if team_id
         end
 
-        EventParser.parse(parsed)
+        events = EventParser.parse(parsed)
+        classify_message_events(events, parsed)
       end
 
       # Outbound
@@ -176,7 +185,7 @@ module ChatSDK
         )
       end
 
-      def edit_message(channel_id:, message_id:, message:)
+      def edit_message(channel_id:, message_id:, message:, **_options)
         msg = ChatSDK::PostableMessage.from(message)
         params = {channel: channel_id, ts: message_id}
 
@@ -185,7 +194,7 @@ module ChatSDK
         client.chat_update(**params)
       end
 
-      def delete_message(channel_id:, message_id:)
+      def delete_message(channel_id:, message_id:, **_options)
         client.chat_delete(channel: channel_id, ts: message_id)
       end
 
@@ -200,17 +209,19 @@ module ChatSDK
       end
 
       def upload_file(channel_id:, io:, filename:, thread_id: nil, comment: nil)
-        params = {channels: channel_id, file: Faraday::Multipart::FilePart.new(io, nil, filename)}
+        content = io.read
+        io.rewind if io.respond_to?(:rewind)
+        params = {channel_id: channel_id, filename: filename, content: content}
         params[:thread_ts] = thread_id if thread_id
         params[:initial_comment] = comment if comment
-        client.files_upload(**params)
+        client.files_upload_v2(**params)
       end
 
-      def add_reaction(channel_id:, message_id:, emoji:)
+      def add_reaction(channel_id:, message_id:, emoji:, **_options)
         client.reactions_add(channel: channel_id, timestamp: message_id, name: emoji)
       end
 
-      def remove_reaction(channel_id:, message_id:, emoji:)
+      def remove_reaction(channel_id:, message_id:, emoji:, **_options)
         client.reactions_remove(channel: channel_id, timestamp: message_id, name: emoji)
       end
 
@@ -314,11 +325,21 @@ module ChatSDK
         result["channel"]
       end
 
-      def start_typing(channel_id:, thread_id: nil)
+      def start_typing(channel_id:, thread_id: nil, message_id: nil)
         # Slack doesn't have a native typing indicator API for bots
         # This is a no-op but the capability is declared for streaming support
       end
 
+      def concurrency_scope(event)
+        return unless @client_id
+
+        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]
+      end
+
       # Slack-specific: receive real-time events via Socket Mode WebSocket.
       # Requires the optional 'faye-websocket' gem and an app-level token (xapp-*).
       # Not part of the base adapter contract.
@@ -330,9 +351,18 @@ module ChatSDK
       def start_socket_mode(app_token: nil, &block)
         app_token ||= ENV["SLACK_APP_TOKEN"]
         raise ChatSDK::ConfigurationError, "Slack app_token required for socket mode" unless app_token
+        raise ArgumentError, "start requires a block" unless block
 
         @socket_mode = SocketMode.new(app_token: app_token, bot_client: client)
-        @socket_mode.start(&block)
+        @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)
+          block.call(event)
+        end
       end
 
       def stop_socket_mode
@@ -353,21 +383,99 @@ module ChatSDK
 
       private
 
+      def build_client(token: nil)
+        options = {}
+        options[:token] = token if token
+        options[:proxy] = @proxy if @proxy
+        options.empty? ? ::Slack::Web::Client.new : ::Slack::Web::Client.new(options)
+      end
+
+      def classify_message_events(events, payload)
+        events.each do |event|
+          next unless %i[mention subscribed_message direct_message].include?(event.type)
+
+          event.message.is_mention = classify_mention(event, payload)
+        end
+        events
+      end
+
+      def classify_mention(event, payload)
+        raw_event = payload["event"] || {}
+        return true if raw_event["type"] == "app_mention"
+
+        bot_user_id = resolve_bot_user_id(event)
+        return true if event.type == :mention && bot_user_id.nil?
+        return nil if bot_user_id.nil?
+
+        text = raw_event["text"].to_s
+        masked_text = ChatSDK::Format::Mentions.mask_code_spans(text)
+        text_mentions_bot = /<@#{Regexp.escape(bot_user_id)}(?:\|[^>]*)?>/.match?(masked_text)
+        text_mentions_bot || rich_text_mentions_bot?(raw_event["blocks"], bot_user_id)
+      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
+
+        return @bot_user_id if @bot_user_id
+
+        current_client = if @client_id
+          resolve_team_client(team_id) if team_id
+        else
+          @client
+        end
+        return unless current_client
+
+        @bot_user_id_mutex.synchronize do
+          cache_key = @client_id ? (team_id || :default) : :default
+          return @bot_user_ids[cache_key] if @bot_user_ids.key?(cache_key)
+
+          bot_user_id = begin
+            current_client.auth_test["user_id"]
+          rescue ::Slack::Web::Api::Errors::SlackError, Faraday::Error, SocketError, Timeout::Error
+            nil
+          end
+          @bot_user_ids[cache_key] = bot_user_id if bot_user_id
+          bot_user_id
+        end
+      end
+
+      def invalidate_bot_user_id(team_id)
+        @bot_user_id_mutex.synchronize { @bot_user_ids.delete(team_id) }
+      end
+
+      def rich_text_mentions_bot?(blocks, bot_user_id)
+        Array(blocks).any? { |block| rich_text_element_mentions_bot?(block, bot_user_id) }
+      end
+
+      def rich_text_element_mentions_bot?(element, bot_user_id)
+        return false unless element.is_a?(Hash)
+        return false if %w[rich_text_preformatted preformatted code].include?(element["type"])
+        return false if element.dig("style", "code")
+        return true if element["type"] == "user" && element["user_id"] == bot_user_id
+
+        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
 
         cached = @team_clients[team_id]
         if cached
           ::Thread.current[:chat_sdk_slack_client] = cached
-          return
+          return cached
         end
 
         installation = get_installation(team_id)
         return unless installation
 
-        new_client = ::Slack::Web::Client.new(token: installation["bot_token"])
+        new_client = build_client(token: installation["bot_token"])
         @team_clients[team_id] = new_client
         ::Thread.current[:chat_sdk_slack_client] = new_client
+        new_client
       end
 
       def installation_key(team_id)

data/lib/chat_sdk/slack/block_kit_renderer.rb

@@ -13,7 +13,17 @@ module ChatSDK
       private
 
       def render_card(node)
-        node.children.map { |child| render_node(child) }.compact
+        @used_native_table = false
+        @chart_count = 0
+        blocks = []
+        if node.attributes[:title]
+          blocks << {type: "header", text: {type: "plain_text", text: truncate_text(node.attributes[:title], 150)}}
+        end
+        if node.attributes[:subtitle]
+          blocks << {type: "context", elements: [{type: "mrkdwn", text: truncate_mrkdwn(node.attributes[:subtitle], 3000)}]}
+        end
+        blocks.concat(node.children.map { |child| render_node(child) }.compact)
+        blocks
       end
 
       def render_node(node)
@@ -24,19 +34,22 @@ module ChatSDK
         when :fields then render_fields(node)
         when :section then render_section(node)
         when :actions then render_actions(node)
+        when :table then render_table(node)
+        when :chart then render_chart(node)
+        when :text_input then {type: "section", text: {type: "mrkdwn", text: truncate_mrkdwn(node.attributes[:label], 3000)}}
         end
       end
 
       def render_text(node)
         {
           type: "section",
-          text: {type: "mrkdwn", text: node.attributes[:content]}
+          text: {type: "mrkdwn", text: truncate_mrkdwn(node.attributes[:content], 3000)}
         }
       end
 
       def render_image(node)
         block = {type: "image", image_url: node.attributes[:url]}
-        block[:alt_text] = node.attributes[:alt] || " "
+        block[:alt_text] = truncate_text(node.attributes[:alt] || " ", 2000)
         block
       end
 
@@ -44,7 +57,7 @@ module ChatSDK
         {
           type: "section",
           fields: node.children.map do |field|
-            {type: "mrkdwn", text: "*#{field.attributes[:label]}*\n#{field.attributes[:value]}"}
+            {type: "mrkdwn", text: truncate_mrkdwn("*#{field.attributes[:label]}*\n#{field.attributes[:value]}", 2000)}
           end
         }
       end
@@ -53,7 +66,7 @@ module ChatSDK
         block = {type: "section"}
         text_children = node.children.select { |c| c.type == :text }
         if text_children.any?
-          block[:text] = {type: "mrkdwn", text: text_children.map { |t| t.attributes[:content] }.join("\n")}
+          block[:text] = {type: "mrkdwn", text: truncate_mrkdwn(text_children.map { |t| t.attributes[:content] }.join("\n"), 3000)}
         end
         block
       end
@@ -76,7 +89,7 @@ module ChatSDK
       def render_button(node)
         btn = {
           type: "button",
-          text: {type: "plain_text", text: node.attributes[:text]},
+          text: {type: "plain_text", text: truncate_text(node.attributes[:text], 75)},
           action_id: node.attributes[:id]
         }
         btn[:value] = node.attributes[:value] if node.attributes[:value]
@@ -85,16 +98,19 @@ module ChatSDK
         elsif node.attributes[:style] == :danger
           btn[:style] = "danger"
         end
+        btn[:visible_to_user_ids] = node.attributes[:visible_to] if node.attributes[:visible_to]&.any?
         btn
       end
 
       def render_link_button(node)
-        {
+        button = {
           type: "button",
-          text: {type: "plain_text", text: node.attributes[:text]},
+          text: {type: "plain_text", text: truncate_text(node.attributes[:text], 75)},
           url: node.attributes[:url],
-          action_id: "link_#{node.attributes[:url].hash.abs}"
+          action_id: node.attributes[:id] || "link_#{node.attributes[:url].hash.abs}"
         }
+        button[:visible_to_user_ids] = node.attributes[:visible_to] if node.attributes[:visible_to]&.any?
+        button
       end
 
       def render_select(node)
@@ -104,21 +120,129 @@ module ChatSDK
           options: node.children.map { |opt| render_option(opt) }
         }
         if node.attributes[:placeholder]
-          sel[:placeholder] = {type: "plain_text", text: node.attributes[:placeholder]}
+          sel[:placeholder] = {type: "plain_text", text: truncate_text(node.attributes[:placeholder], 150)}
         end
         sel
       end
 
       def render_option(node)
         opt = {
-          text: {type: "plain_text", text: node.attributes[:text]},
+          text: {type: "plain_text", text: truncate_text(node.attributes[:text], 75)},
           value: node.attributes[:value]
         }
         if node.attributes[:description]
-          opt[:description] = {type: "plain_text", text: node.attributes[:description]}
+          opt[:description] = {type: "plain_text", text: truncate_text(node.attributes[:description], 75)}
         end
         opt
       end
+
+      def render_table(node)
+        headers = Array(node.attributes[:headers])
+        rows = Array(node.attributes[:rows])
+        char_count = (headers + rows.flatten).sum { |cell| cell.to_s.length }
+        if @used_native_table || rows.length > 100 || headers.length > 20 || char_count > 10_000
+          return fallback_block(ChatSDK::Cards::Renderer.new.render(node))
+        end
+
+        @used_native_table = true
+        rendered_rows = [headers, *rows].map do |row|
+          Array(row).map { |cell| {type: "raw_text", text: cell.to_s.empty? ? " " : cell.to_s} }
+        end
+        return {type: "table", rows: rendered_rows} if rows.empty?
+
+        block = {
+          type: "data_table",
+          caption: node.attributes[:caption] || "Table",
+          rows: rendered_rows
+        }
+        block[:page_size] = node.attributes[:page_size].to_i.clamp(1, 100) if node.attributes[:page_size]
+        block
+      end
+
+      def render_chart(node)
+        return fallback_block(node.fallback_text) if @chart_count >= 2
+
+        block = chart_block(node)
+        return fallback_block(node.fallback_text) unless block
+
+        @chart_count += 1
+        block
+      end
+
+      def chart_block(node)
+        title = node.attributes[:title].to_s
+        return if title.empty? || title.length > 50
+
+        type = node.attributes[:chart_type].to_sym
+        if type == :pie
+          segments = Array(node.attributes[:segments])
+          return unless segments.length.between?(1, 12) && segments.all? { |segment| valid_chart_label?(value_for(segment, :label)) && value_for(segment, :value).to_f.positive? }
+
+          return {type: "data_visualization", title: title, chart: {type: "pie", segments: segments}}
+        end
+
+        categories = Array(node.attributes[:categories])
+        series = Array(node.attributes[:series])
+        return unless %i[bar area line].include?(type)
+        return unless categories.length.between?(1, 20) && categories.all? { |category| valid_chart_label?(category) }
+        return unless series.length.between?(1, 12) && series.all? { |item| valid_chart_label?(value_for(item, :name)) }
+
+        axis = {categories: categories}
+        axis[:x_label] = node.attributes[:x_label] if node.attributes[:x_label]
+        axis[:y_label] = node.attributes[:y_label] if node.attributes[:y_label]
+        {type: "data_visualization", title: title, chart: {type: type.to_s, series: series, axis_config: axis}}
+      end
+
+      def valid_chart_label?(label)
+        label.to_s.length.between?(1, 20)
+      end
+
+      def value_for(hash, key)
+        hash[key] || hash[key.to_s]
+      end
+
+      def fallback_block(text)
+        {type: "section", text: {type: "mrkdwn", text: truncate_mrkdwn("```#{text}```", 3000)}}
+      end
+
+      def truncate_text(text, limit)
+        text = text.to_s
+        return text if text.length <= limit
+
+        "#{text[0, limit - 1]}…"
+      end
+
+      def truncate_mrkdwn(text, limit)
+        text = text.to_s
+        return text if text.length <= limit
+
+        prefix = clean_prefix(text[0, limit - 1])
+        4.times do
+          bold_close = prefix.count("*").odd? ? "*" : ""
+          fence_close = open_fence?(prefix) ? "\n```" : ""
+          available = limit - 1 - bold_close.length - fence_close.length
+          next_prefix = clean_prefix(text[0, available])
+          break if next_prefix == prefix
+
+          prefix = next_prefix
+        end
+
+        bold_close = prefix.count("*").odd? ? "*" : ""
+        fence_close = open_fence?(prefix) ? "\n```" : ""
+        suffix = "#{bold_close}…#{fence_close}"
+        prefix = clean_prefix(prefix[0, limit - suffix.length]) while prefix.length + suffix.length > limit
+        "#{prefix}#{suffix}"
+      end
+
+      def clean_prefix(text)
+        text
+          .sub(/<(?:[@#!]|[a-z][a-z\d+.-]*(?::|$))[^>]*\z/i, "")
+          .sub(/&(?:#?[a-z\d]*)?\z/i, "")
+      end
+
+      def open_fence?(text)
+        text.scan("```").length.odd?
+      end
     end
   end
 end

data/lib/chat_sdk/slack/event_parser.rb

@@ -50,7 +50,7 @@ module ChatSDK
           )
           message = ChatSDK::Message.new(
             id: event["ts"],
-            text: event["text"] || "",
+            text: message_text(event),
             author: author,
             thread_id: event["thread_ts"] || event["ts"],
             channel_id: event["channel"],
@@ -68,6 +68,8 @@ module ChatSDK
         end
 
         def parse_message_event(event, payload)
+          return parse_message_updated(event, payload) if event["subtype"] == "message_changed"
+          return parse_message_deleted(event, payload) if event["subtype"] == "message_deleted"
           return [] if event["subtype"] && event["subtype"] != "file_share"
           return [] if event["bot_id"]
 
@@ -78,7 +80,7 @@ module ChatSDK
           )
           message = ChatSDK::Message.new(
             id: event["ts"],
-            text: event["text"] || "",
+            text: message_text(event),
             author: author,
             thread_id: event["thread_ts"] || event["ts"],
             channel_id: event["channel"],
@@ -108,6 +110,103 @@ module ChatSDK
           end
         end
 
+        def parse_message_updated(event, payload)
+          return [] if event["hidden"]
+
+          message_data = event["message"]
+          return [] unless message_data
+
+          channel_id = event["channel"] || message_data["channel"]
+          message = slack_message(message_data, channel_id)
+          previous = slack_message(event["previous_message"], channel_id) if event["previous_message"]
+          [ChatSDK::Events::MessageUpdated.new(
+            message: message,
+            previous_message: previous,
+            thread_id: message.thread_id,
+            channel_id: channel_id,
+            platform: :slack,
+            adapter_name: :slack,
+            raw: payload
+          )]
+        end
+
+        def message_text(event)
+          blocks = event["blocks"]
+          text = if blocks.is_a?(Array) && !blocks.empty? && blocks.all? { |block| %w[section header context image divider actions table].include?(block["type"]) }
+            blocks.filter_map { |block| block_text(block) }.join("\n")
+          else
+            event["text"] || ""
+          end
+          FormatConverter.new.normalize_inbound_text(text)
+        end
+
+        def block_text(block)
+          case block["type"]
+          when "section", "header"
+            texts = [block.dig("text", "text")]
+            texts.concat(Array(block["fields"]).map { |field| field["text"] })
+            texts.compact.reject(&:empty?).join("\n")
+          when "context"
+            Array(block["elements"]).filter_map { |element| element.dig("text") }.reject(&:empty?).join("\n")
+          when "image"
+            block["alt_text"]
+          when "actions"
+            Array(block["elements"]).filter_map do |element|
+              element.dig("text", "text") || element.dig("placeholder", "text")
+            end.reject(&:empty?).join(" ")
+          when "table"
+            Array(block["rows"]).map do |row|
+              Array(row).map { |cell| cell.dig("text") || cell.to_s }.join(" | ")
+            end.join("\n")
+          end
+        end
+
+        def parse_message_deleted(event, payload)
+          previous = event["previous_message"]
+          message_id = event["deleted_ts"] || previous&.dig("ts")
+          return [] unless message_id
+
+          channel_id = event["channel"] || previous&.dig("channel")
+          previous_message = slack_message(previous, channel_id) if previous
+          thread_id = previous&.dig("thread_ts") || message_id
+          [ChatSDK::Events::MessageDeleted.new(
+            message_id: message_id,
+            previous_message: previous_message,
+            thread_id: thread_id,
+            channel_id: channel_id,
+            deleted_at: slack_time(event["event_ts"] || event["ts"]),
+            platform: :slack,
+            adapter_name: :slack,
+            raw: payload
+          )]
+        end
+
+        def slack_message(data, channel_id)
+          user_id = data["user"] || data.dig("bot_profile", "user_id") || "unknown"
+          ChatSDK::Message.new(
+            id: data["ts"],
+            text: data["text"] || "",
+            author: ChatSDK::Author.new(
+              id: user_id,
+              name: data["username"] || user_id,
+              platform: :slack,
+              bot: !!data["bot_id"],
+              system: user_id == "USLACK"
+            ),
+            thread_id: data["thread_ts"] || data["ts"],
+            channel_id: channel_id,
+            platform: :slack,
+            timestamp: slack_time(data["ts"]),
+            raw: data
+          )
+        end
+
+        def slack_time(value)
+          Time.at(Float(value)) if value
+        rescue ArgumentError, TypeError
+          nil
+        end
+
         def parse_reaction(event, payload, added:)
           [ChatSDK::Events::Reaction.new(
             emoji: event["reaction"],

data/lib/chat_sdk/slack/format_converter.rb

@@ -19,6 +19,23 @@ module ChatSDK
         parts.map.with_index { |part, i| i.odd? ? part : convert_md_to_mrkdwn(part) }.join
       end
 
+      def normalize_inbound_text(text)
+        return "" if text.nil? || text.empty?
+
+        split_code_blocks(text).map.with_index do |part, index|
+          if index.odd?
+            part
+          else
+            part
+              .gsub("<!here>", "@here")
+              .gsub("<!channel>", "@channel")
+              .gsub("<!everyone>", "@everyone")
+              .gsub(/<!subteam\^[^|>]+\|(@[^>]+)>/, '\1')
+              .gsub(/<(?:mailto|tel):[^>|]+\|([^>]+)>/, '\1')
+          end
+        end.join
+      end
+
       private
 
       # ── Slack mrkdwn → Markdown ──────────────────────────────────────────

data/lib/chat_sdk/slack/modal_renderer.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "date"
+
 module ChatSDK
   module Slack
     class ModalRenderer
@@ -49,10 +51,37 @@ module ChatSDK
           }
           el[:placeholder] = {type: "plain_text", text: node.attributes[:placeholder]} if node.attributes[:placeholder]
           el
+        when :date
+          el = {type: "datepicker", action_id: node.attributes[:id]}
+          initial_date = valid_initial_date(node.attributes[:initial_value])
+          el[:initial_date] = initial_date if initial_date
+          el[:placeholder] = {type: "plain_text", text: node.attributes[:placeholder]} if node.attributes[:placeholder]
+          el
+        when :number
+          el = {
+            type: "number_input",
+            action_id: node.attributes[:id],
+            is_decimal_allowed: !!node.attributes[:decimal]
+          }
+          el[:min_value] = node.attributes[:min].to_s unless node.attributes[:min].nil?
+          el[:max_value] = node.attributes[:max].to_s unless node.attributes[:max].nil?
+          el[:initial_value] = node.attributes[:initial_value].to_s unless node.attributes[:initial_value].nil?
+          el[:placeholder] = {type: "plain_text", text: node.attributes[:placeholder]} if node.attributes[:placeholder]
+          el
         end
         block
       end
 
+      def valid_initial_date(value)
+        return unless value
+
+        parsed = Date.iso8601(value.to_s)
+        value.to_s if parsed.iso8601 == value.to_s
+      rescue Date::Error
+        ChatSDK::Log.warn("Ignoring invalid modal initial date: #{value.inspect}")
+        nil
+      end
+
       def render_text(node)
         {
           type: "section",

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: chat_sdk-slack
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.2.0
 platform: ruby
 authors:
 - Quentin Rousseau
@@ -15,14 +15,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: '1.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: '1.2'
 - !ruby/object:Gem::Dependency
   name: slack-ruby-client
   requirement: !ruby/object:Gem::Requirement