chat_sdk-slack 1.1.0 → 1.3.0

data/lib/chat_sdk/slack/block_kit_renderer.rb

@@ -15,12 +15,28 @@ module ChatSDK
       def render_card(node)
         @used_native_table = false
         @chart_count = 0
-        node.children.map { |child| render_node(child) }.compact
+        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
+        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
 
       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)
@@ -28,19 +44,31 @@ module ChatSDK
         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)
+        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: node.attributes[:content]}
+          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] = node.attributes[:alt] || " "
+        block[:alt_text] = truncate_text(node.attributes[:alt] || " ", 2000)
         block
       end
 
@@ -48,16 +76,21 @@ 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
 
       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: text_children.map { |t| t.attributes[:content] }.join("\n")}
+        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
@@ -74,13 +107,14 @@ 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
 
       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]
@@ -89,16 +123,24 @@ 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: 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
 
       def render_select(node)
@@ -108,18 +150,41 @@ 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
+        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: 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
@@ -190,7 +255,46 @@ module ChatSDK
       end
 
       def fallback_block(text)
-        {type: "section", text: {type: "mrkdwn", text: "```#{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

data/lib/chat_sdk/slack/chat_streamer.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require "json"
+
+module ChatSDK
+  module Slack
+    class ChatStreamer
+      attr_reader :ts
+
+      def initialize(client, channel:, thread_ts:, recipient_user_id: nil,
+        recipient_team_id: nil, task_display_mode: nil, buffer_size: 256)
+        @client = client
+        @stream_args = {channel: channel, thread_ts: thread_ts}
+        @stream_args[:recipient_user_id] = recipient_user_id if recipient_user_id
+        @stream_args[:recipient_team_id] = recipient_team_id if recipient_team_id
+        @stream_args[:task_display_mode] = task_display_mode if task_display_mode
+        @buffer_size = buffer_size
+        @buffer = +""
+        @state = :starting
+        @token = nil
+        @ts = nil
+      end
+
+      def append(markdown_text: nil, chunks: nil, **options)
+        ensure_open!(:append)
+        @token = options.delete(:token) if options[:token]
+        @buffer << markdown_text if markdown_text && !markdown_text.empty?
+        return unless @buffer.length >= @buffer_size || !chunks.nil?
+
+        flush_buffer(chunks, options)
+      end
+
+      def stop(markdown_text: nil, chunks: nil, blocks: nil, **options)
+        ensure_open!(:stop)
+        @token = options.delete(:token) if options[:token]
+        @buffer << markdown_text if markdown_text && !markdown_text.empty?
+
+        start_stream unless ts
+
+        stop_chunks = chunks_for_flush(chunks)
+        params = {
+          token: @token,
+          channel: @stream_args[:channel],
+          ts: ts,
+          chunks: JSON.generate(stop_chunks)
+        }
+        params[:blocks] = JSON.generate(blocks) if blocks
+        params.merge!(options)
+        response = call_api(:chat_stopStream, "chat.stopStream", params)
+        @buffer.clear
+        @state = :completed
+        response
+      end
+
+      private
+
+      def flush_buffer(chunks, options)
+        payload = chunks_for_flush(chunks)
+        params = {
+          token: @token,
+          chunks: JSON.generate(payload)
+        }.merge(options)
+
+        if ts
+          params[:channel] = @stream_args[:channel]
+          params[:ts] = ts
+          response = call_api(:chat_appendStream, "chat.appendStream", params)
+        else
+          response = call_api(
+            :chat_startStream,
+            "chat.startStream",
+            @stream_args.merge(params)
+          )
+          @ts = response_value(response, :ts)
+          @state = :in_progress
+        end
+
+        @buffer.clear
+        response
+      end
+
+      def start_stream
+        response = call_api(
+          :chat_startStream,
+          "chat.startStream",
+          @stream_args.merge(token: @token)
+        )
+        @ts = response_value(response, :ts)
+        raise ChatSDK::Error, "failed to stop stream: stream not started" unless ts
+
+        @state = :in_progress
+      end
+
+      def chunks_for_flush(chunks)
+        payload = []
+        unless @buffer.empty?
+          payload << {type: "markdown_text", text: @buffer}
+        end
+        Array(chunks).each do |chunk|
+          payload << (chunk.respond_to?(:to_h) ? chunk.to_h : chunk)
+        end
+        payload
+      end
+
+      def call_api(method, endpoint, params)
+        if @client.respond_to?(method)
+          @client.public_send(method, **params)
+        else
+          @client.post(endpoint, params)
+        end
+      end
+
+      def response_value(response, key)
+        response[key.to_s] || response[key]
+      end
+
+      def ensure_open!(action)
+        return unless @state == :completed
+
+        raise ChatSDK::Error, "failed to #{action} stream: stream state is #{@state}"
+      end
+    end
+  end
+end

data/lib/chat_sdk/slack/event_parser.rb

@@ -37,11 +37,64 @@ module ChatSDK
             parse_reaction(event, payload, added: true)
           when "reaction_removed"
             parse_reaction(event, payload, added: false)
+          when "assistant_thread_started"
+            parse_assistant_thread(event, payload, ChatSDK::Events::AssistantThreadStarted)
+          when "assistant_thread_context_changed"
+            parse_assistant_thread(event, payload, ChatSDK::Events::AssistantContextChanged)
+          when "app_home_opened"
+            parse_app_home_opened(event, payload)
+          when "member_joined_channel"
+            parse_member_joined_channel(event, payload)
           else
             []
           end
         end
 
+        def parse_assistant_thread(event, payload, event_class)
+          assistant_thread = event["assistant_thread"]
+          return [] unless assistant_thread
+
+          thread_ts = assistant_thread["thread_ts"]
+          context = assistant_thread["context"] || {}
+          [event_class.new(
+            thread_id: thread_ts,
+            channel_id: assistant_thread["channel_id"],
+            thread_ts: thread_ts,
+            user_id: assistant_thread["user_id"],
+            context: context,
+            platform: :slack,
+            adapter_name: :slack,
+            raw: payload,
+            timestamp: slack_time(event["event_ts"])
+          )]
+        end
+
+        def parse_app_home_opened(event, payload)
+          return [] unless event["tab"] == "home"
+
+          [ChatSDK::Events::AppHomeOpened.new(
+            user_id: event["user"],
+            channel_id: event["channel"],
+            tab: event["tab"],
+            platform: :slack,
+            adapter_name: :slack,
+            raw: payload,
+            timestamp: slack_time(event["event_ts"])
+          )]
+        end
+
+        def parse_member_joined_channel(event, payload)
+          [ChatSDK::Events::MemberJoinedChannel.new(
+            user_id: event["user"],
+            channel_id: event["channel"],
+            inviter_id: event["inviter"],
+            platform: :slack,
+            adapter_name: :slack,
+            raw: payload,
+            timestamp: slack_time(event["event_ts"])
+          )]
+        end
+
         def parse_mention(event, payload)
           author = ChatSDK::Author.new(
             id: event["user"],
@@ -50,7 +103,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"],
@@ -80,7 +133,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"],
@@ -130,6 +183,37 @@ module ChatSDK
           )]
         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")

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

@@ -11,6 +11,9 @@ module ChatSDK
           title: {type: "plain_text", text: node.attributes[:title]}
         }
         view[:callback_id] = node.attributes[:callback_id] if node.attributes[:callback_id]
+        if node.attributes[:close_label] && !node.attributes[:close_label].empty?
+          view[:close] = {type: "plain_text", text: node.attributes[:close_label]}
+        end
         if node.attributes[:submit_label]
           view[:submit] = {type: "plain_text", text: node.attributes[:submit_label]}
         end
@@ -24,6 +27,7 @@ module ChatSDK
         case node.type
         when :input then render_input(node)
         when :text then render_text(node)
+        when :fields then render_fields(node)
         end
       end
 
@@ -42,6 +46,10 @@ module ChatSDK
             multiline: !!node.attributes[:multiline]
           }
           el[:placeholder] = {type: "plain_text", text: node.attributes[:placeholder]} if node.attributes[:placeholder]
+          if node.attributes[:initial_value] && !node.attributes[:initial_value].empty?
+            el[:initial_value] = node.attributes[:initial_value]
+          end
+          el[:max_length] = node.attributes[:max_length] if node.attributes[:max_length] && !node.attributes[:max_length].zero?
           el
         when :select
           el = {
@@ -50,6 +58,26 @@ module ChatSDK
             options: node.children.map { |opt| render_option(opt) }
           }
           el[:placeholder] = {type: "plain_text", text: node.attributes[:placeholder]} if node.attributes[:placeholder]
+          if node.attributes[:initial_option] && !node.attributes[:initial_option].empty?
+            initial_option = el[:options].find { |option| option[:value] == node.attributes[:initial_option] }
+            el[:initial_option] = initial_option if initial_option
+          end
+          el
+        when :radio_select
+          options = node.children.first(10).map { |option| render_radio_option(option) }
+          el = {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] }
+            el[:initial_option] = initial_option if initial_option
+          end
+          el
+        when :external_select
+          el = {type: "external_select", action_id: node.attributes[:id]}
+          el[:placeholder] = {type: "plain_text", text: node.attributes[:placeholder]} if node.attributes[:placeholder]
+          el[:min_query_length] = node.attributes[:min_query_length] unless node.attributes[:min_query_length].nil?
+          if node.attributes[:initial_option]
+            el[:initial_option] = render_external_option(node.attributes[:initial_option])
+          end
           el
         when :date
           el = {type: "datepicker", action_id: node.attributes[:id]}
@@ -69,6 +97,7 @@ module ChatSDK
           el[:placeholder] = {type: "plain_text", text: node.attributes[:placeholder]} if node.attributes[:placeholder]
           el
         end
+        block[:dispatch_action] = node.attributes[:dispatch_action] unless node.attributes[:dispatch_action].nil?
         block
       end
 
@@ -97,6 +126,33 @@ module ChatSDK
         opt[:description] = {type: "plain_text", text: node.attributes[:description]} if node.attributes[:description]
         opt
       end
+
+      def render_radio_option(node)
+        option = {
+          text: {type: "mrkdwn", text: node.attributes[:text]},
+          value: node.attributes[:value]
+        }
+        option[:description] = {type: "mrkdwn", text: node.attributes[:description]} if node.attributes[:description]
+        option
+      end
+
+      def render_external_option(option)
+        label = option[:label] || option["label"]
+        value = option[:value] || option["value"]
+        description = option[:description] || option["description"]
+        rendered = {text: {type: "plain_text", text: label}, value: value}
+        rendered[:description] = {type: "plain_text", text: description} if description
+        rendered
+      end
+
+      def render_fields(node)
+        {
+          type: "section",
+          fields: node.children.map do |field|
+            {type: "mrkdwn", text: "*#{field.attributes[:label]}*\n#{field.attributes[:value]}"}
+          end
+        }
+      end
     end
   end
 end