chat_sdk-slack 1.2.0 → 1.3.0

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"],

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