chat_sdk 1.0.1 → 1.2.0

data/lib/chat_sdk/event_serializer.rb

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+require "json"
+require "time"
+
+module ChatSDK
+  class EventSerializer
+    class << self
+      def dump(event)
+        data = common_event(event)
+        case event.type
+        when :mention, :subscribed_message, :direct_message, :message_updated
+          data["message"] = dump_message(event.message)
+          data["previous_message"] = dump_message(event.previous_message) if event.respond_to?(:previous_message) && event.previous_message
+        when :message_deleted
+          data.merge!(
+            "message_id" => event.message_id,
+            "previous_message" => dump_message(event.previous_message),
+            "deleted_at" => event.deleted_at&.iso8601
+          )
+        when :reaction
+          data.merge!("emoji" => event.emoji, "user_id" => event.user_id, "message_id" => event.message_id, "added" => event.added?)
+        when :action
+          data.merge!("action_id" => event.action_id, "value" => event.value, "values" => json_safe(event.values), "user" => dump_author(event.user), "trigger_id" => event.trigger_id)
+        when :slash_command
+          data.merge!("command" => event.command, "text" => event.text, "user_id" => event.user_id, "trigger_id" => event.trigger_id)
+        when :installed, :uninstalled
+          data.merge!(
+            "installation_id" => event.installation_id,
+            "team_id" => event.team_id,
+            "tenant_id" => event.tenant_id,
+            "conversation_id" => event.conversation_id,
+            "action" => event.action,
+            "user" => dump_author(event.user)
+          )
+        end
+        data
+      end
+
+      def load(data)
+        data = data.transform_keys(&:to_s)
+        type = data.fetch("type").to_sym
+        common = {
+          thread_id: data["thread_id"],
+          channel_id: data["channel_id"],
+          platform: data["platform"].to_sym,
+          adapter_name: data["adapter_name"].to_sym,
+          raw: data["raw"],
+          timestamp: parse_time(data["timestamp"])
+        }
+        case type
+        when :mention, :subscribed_message, :direct_message
+          class_name = {mention: Events::Mention, subscribed_message: Events::SubscribedMessage, direct_message: Events::DirectMessage}.fetch(type)
+          class_name.new(message: load_message(data["message"]), **common)
+        when :message_updated
+          Events::MessageUpdated.new(message: load_message(data["message"]), previous_message: load_message(data["previous_message"]), **common)
+        when :message_deleted
+          Events::MessageDeleted.new(
+            message_id: data["message_id"],
+            previous_message: load_message(data["previous_message"]),
+            deleted_at: parse_time(data["deleted_at"]),
+            **common
+          )
+        when :reaction
+          Events::Reaction.new(emoji: data["emoji"], user_id: data["user_id"], message_id: data["message_id"], added: data["added"], **common)
+        when :action
+          Events::Action.new(action_id: data["action_id"], value: data["value"], values: data["values"], user: load_author(data["user"]), trigger_id: data["trigger_id"], **common)
+        when :slash_command
+          common.delete(:thread_id)
+          Events::SlashCommand.new(command: data["command"], text: data["text"], user_id: data["user_id"], trigger_id: data["trigger_id"], **common)
+        when :installed, :uninstalled
+          common.delete(:thread_id)
+          common.delete(:channel_id)
+          event_class = if type == :installed
+            Events::Installed
+          else
+            Events::Uninstalled
+          end
+          event_class.new(
+            installation_id: data["installation_id"],
+            team_id: data["team_id"],
+            tenant_id: data["tenant_id"],
+            conversation_id: data["conversation_id"],
+            action: data["action"],
+            user: load_author(data["user"]),
+            **common
+          )
+        else
+          raise ArgumentError, "unsupported queued event type: #{type}"
+        end
+      end
+
+      private
+
+      def common_event(event)
+        {
+          "type" => event.type.to_s,
+          "platform" => event.platform.to_s,
+          "adapter_name" => event.adapter_name.to_s,
+          "thread_id" => event.respond_to?(:thread_id) ? event.thread_id : nil,
+          "channel_id" => event.respond_to?(:channel_id) ? event.channel_id : nil,
+          "raw" => json_safe(event.raw),
+          "timestamp" => event.timestamp&.iso8601
+        }
+      end
+
+      def dump_message(message)
+        return unless message
+
+        {
+          "id" => message.id,
+          "text" => message.text,
+          "author" => dump_author(message.author),
+          "thread_id" => message.thread_id,
+          "channel_id" => message.channel_id,
+          "platform" => message.platform.to_s,
+          "attachments" => json_safe(message.attachments),
+          "links" => json_safe(message.links),
+          "reply_to" => dump_message(message.reply_to),
+          "subject" => json_safe(message.subject),
+          "raw" => json_safe(message.raw),
+          "timestamp" => message.timestamp&.iso8601,
+          "is_mention" => message.is_mention
+        }
+      end
+
+      def load_message(data)
+        return unless data
+
+        data = data.transform_keys(&:to_s)
+        Message.new(
+          id: data["id"],
+          text: data["text"],
+          author: load_author(data["author"]),
+          thread_id: data["thread_id"],
+          channel_id: data["channel_id"],
+          platform: data["platform"].to_sym,
+          attachments: data["attachments"] || [],
+          links: data["links"] || [],
+          reply_to: load_message(data["reply_to"]),
+          subject: data["subject"],
+          raw: data["raw"],
+          timestamp: parse_time(data["timestamp"]),
+          is_mention: data["is_mention"]
+        )
+      end
+
+      def dump_author(author)
+        return unless author
+
+        {
+          "id" => author.id,
+          "name" => author.name,
+          "platform" => author.platform.to_s,
+          "bot" => author.bot?,
+          "me" => author.me?,
+          "system" => author.system?,
+          "locale" => author.locale,
+          "email" => author.email,
+          "raw" => json_safe(author.raw)
+        }
+      end
+
+      def load_author(data)
+        return unless data
+
+        data = data.transform_keys(&:to_s)
+        Author.new(
+          id: data["id"],
+          name: data["name"],
+          platform: data["platform"].to_sym,
+          bot: data["bot"],
+          me: data["me"],
+          system: data["system"],
+          locale: data["locale"],
+          email: data["email"],
+          raw: data["raw"]
+        )
+      end
+
+      def parse_time(value)
+        Time.iso8601(value) if value
+      end
+
+      def json_safe(value)
+        JSON.parse(JSON.generate(value))
+      rescue JSON::GeneratorError, TypeError
+        nil
+      end
+    end
+  end
+end

data/lib/chat_sdk/events/action.rb

@@ -3,13 +3,14 @@
 module ChatSDK
   module Events
     class Action < Base
-      attr_reader :action_id, :value, :user, :thread_id, :channel_id, :trigger_id
+      attr_reader :action_id, :value, :values, :user, :thread_id, :channel_id, :trigger_id
       attr_accessor :thread
 
-      def initialize(action_id:, thread_id:, channel_id:, value: nil, user: nil, trigger_id: nil, **kwargs)
+      def initialize(action_id:, thread_id:, channel_id:, value: nil, values: nil, user: nil, trigger_id: nil, **kwargs)
         super(type: :action, **kwargs)
         @action_id = action_id
         @value = value
+        @values = values
         @user = user
         @thread_id = thread_id
         @channel_id = channel_id

data/lib/chat_sdk/events/installed.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module ChatSDK
+  module Events
+    class Installed < Base
+      attr_reader :installation_id, :team_id, :tenant_id, :conversation_id, :action, :user
+
+      def initialize(conversation_id:, action:, installation_id: nil, team_id: nil, tenant_id: nil, user: nil, **kwargs)
+        super(type: :installed, **kwargs)
+        @installation_id = installation_id
+        @team_id = team_id
+        @tenant_id = tenant_id
+        @conversation_id = conversation_id
+        @action = action
+        @user = user
+      end
+    end
+  end
+end

data/lib/chat_sdk/events/message_deleted.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module ChatSDK
+  module Events
+    class MessageDeleted < Base
+      attr_reader :message_id, :previous_message, :thread_id, :channel_id, :deleted_at
+      attr_accessor :thread
+
+      def initialize(message_id:, thread_id:, channel_id:, previous_message: nil, deleted_at: nil, **kwargs)
+        super(type: :message_deleted, **kwargs)
+        @message_id = message_id
+        @previous_message = previous_message
+        @thread_id = thread_id
+        @channel_id = channel_id
+        @deleted_at = deleted_at
+      end
+    end
+  end
+end

data/lib/chat_sdk/events/message_updated.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module ChatSDK
+  module Events
+    class MessageUpdated < Base
+      attr_reader :message, :previous_message, :thread_id, :channel_id
+
+      def initialize(message:, thread_id:, channel_id:, previous_message: nil, **kwargs)
+        super(type: :message_updated, **kwargs)
+        @message = message
+        @previous_message = previous_message
+        @thread_id = thread_id
+        @channel_id = channel_id
+      end
+    end
+  end
+end

data/lib/chat_sdk/events/uninstalled.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module ChatSDK
+  module Events
+    class Uninstalled < Base
+      attr_reader :installation_id, :team_id, :tenant_id, :conversation_id, :action, :user
+
+      def initialize(conversation_id:, action:, installation_id: nil, team_id: nil, tenant_id: nil, user: nil, **kwargs)
+        super(type: :uninstalled, **kwargs)
+        @installation_id = installation_id
+        @team_id = team_id
+        @tenant_id = tenant_id
+        @conversation_id = conversation_id
+        @action = action
+        @user = user
+      end
+    end
+  end
+end

data/lib/chat_sdk/format/mentions.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module ChatSDK
+  module Format
+    module Mentions
+      class << self
+        def mask_code_spans(text)
+          characters = text.to_s.chars
+          masked = characters.dup
+          opening = nil
+          opening_length = nil
+          fence = false
+          index = 0
+
+          while index < characters.length
+            if characters[index] == "`"
+              finish = index + 1
+              finish += 1 while finish < characters.length && characters[finish] == "`"
+              length = finish - index
+
+              if opening
+                closes = fence ? length >= 3 : length == opening_length
+                if closes
+                  blank_span(masked, opening, finish)
+                  opening = nil
+                  opening_length = nil
+                  fence = false
+                else
+                  blank_span(masked, index, finish)
+                end
+              else
+                opening = index
+                opening_length = length
+                fence = length >= 3
+                blank_span(masked, index, finish)
+              end
+
+              index = finish
+            else
+              if opening
+                masked[index] = " " unless characters[index] == "\n" || characters[index] == "\r"
+              end
+              index += 1
+            end
+          end
+
+          masked[opening..] = characters[opening..] if opening
+          masked.join
+        end
+
+        private
+
+        def blank_span(characters, first, finish)
+          (first...finish).each do |index|
+            characters[index] = " " unless characters[index] == "\n" || characters[index] == "\r"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chat_sdk/history.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+require "time"
+require "securerandom"
+
+module ChatSDK
+  class History
+    attr_reader :user, :thread, :channel
+
+    def initialize(chat)
+      @user = UserHistory.new(chat)
+      @thread = ThreadHistory.new(chat)
+      @channel = ChannelHistory.new(chat)
+    end
+
+    class UserHistory
+      def initialize(chat)
+        @chat = chat
+      end
+
+      def append(thread, message, user_key: nil)
+        user_key ||= resolve_user_key(thread, message)
+        return nil unless user_key
+
+        entry = normalize_entry(thread, message, user_key)
+        entries = Array(@chat.state.get(storage_key(user_key)))
+        entries << entry
+        max = @chat.config.history_user[:max_per_user]
+        entries = entries.last(max) if max && max != false
+        @chat.state.set(storage_key(user_key), entries, ttl: @chat.config.history_user[:retention])
+        entry
+      end
+
+      def list(user_key:, limit: 50, platforms: nil, thread_id: nil, roles: nil)
+        entries = Array(@chat.state.get(storage_key(user_key)))
+        entries = entries.select { |entry| Array(platforms).map(&:to_s).include?(entry["platform"].to_s) } if platforms
+        entries = entries.select { |entry| entry["thread_id"] == thread_id } if thread_id
+        entries = entries.select { |entry| Array(roles).map(&:to_s).include?(entry["role"].to_s) } if roles
+        limit ? entries.last(limit) : entries
+      end
+
+      def count(user_key:)
+        Array(@chat.state.get(storage_key(user_key))).length
+      end
+
+      def delete(user_key:)
+        count = Array(@chat.state.get(storage_key(user_key))).length
+        @chat.state.delete(storage_key(user_key))
+        {deleted: count}
+      end
+
+      def to_prompt_entries(entries)
+        entries.map { |entry| {role: entry["role"], content: entry["text"]} }
+      end
+
+      private
+
+      def resolve_user_key(thread, message)
+        resolver = @chat.config.history_user[:identity]
+        return resolver.call(thread, message) if resolver
+        message.author.email if message.is_a?(Message) && message.author&.email
+      rescue => e
+        ChatSDK::Log.warn("History identity resolver failed: #{e.message}")
+        nil
+      end
+
+      def normalize_entry(thread, message, user_key)
+        if message.is_a?(Message)
+          {
+            "id" => SecureRandom.uuid,
+            "platform_message_id" => message.id,
+            "user_key" => user_key,
+            "role" => message.author&.bot? ? "assistant" : "user",
+            "text" => message.text.to_s,
+            "platform" => message.platform.to_s,
+            "thread_id" => thread.id,
+            "timestamp" => (message.timestamp || Time.now).iso8601
+          }
+        else
+          data = message.transform_keys(&:to_sym)
+          {
+            "id" => SecureRandom.uuid,
+            "platform_message_id" => data[:platform_message_id] || data[:id],
+            "user_key" => user_key,
+            "role" => (data[:role] || "assistant").to_s,
+            "text" => data[:text].to_s,
+            "platform" => (data[:platform] || thread.adapter.name).to_s,
+            "thread_id" => thread.id,
+            "timestamp" => (data[:timestamp] || Time.now).iso8601
+          }
+        end
+      end
+
+      def storage_key(user_key)
+        "chat_sdk:history:user:#{user_key}"
+      end
+    end
+
+    class ThreadHistory
+      def initialize(chat)
+        @chat = chat
+      end
+
+      def list(thread, cursor: nil, limit: 50)
+        unless thread.is_a?(ChatSDK::Thread)
+          raise ArgumentError, "thread history requires a ChatSDK::Thread"
+        end
+
+        messages, next_cursor = thread.adapter.fetch_messages(
+          channel_id: thread.channel_id,
+          thread_id: thread.id,
+          cursor: cursor,
+          limit: limit
+        )
+        {messages: messages, next_cursor: next_cursor}
+      end
+    end
+
+    class ChannelHistory
+      def initialize(chat)
+        @chat = chat
+      end
+
+      def list_messages(channel, cursor: nil, limit: 50)
+        unless channel.is_a?(ChatSDK::Channel)
+          raise ArgumentError, "channel history requires a ChatSDK::Channel"
+        end
+
+        messages, next_cursor = channel.adapter.fetch_channel_messages(
+          channel_id: channel.id,
+          cursor: cursor,
+          limit: limit
+        )
+        {messages: messages, next_cursor: next_cursor}
+      end
+
+      def list_threads(channel, cursor: nil, limit: 50)
+        unless channel.is_a?(ChatSDK::Channel)
+          raise ArgumentError, "channel history requires a ChatSDK::Channel"
+        end
+
+        threads, next_cursor = channel.adapter.list_threads(
+          channel_id: channel.id,
+          cursor: cursor,
+          limit: limit
+        )
+        {threads: threads, next_cursor: next_cursor}
+      end
+    end
+  end
+end

data/lib/chat_sdk/message.rb

@@ -3,10 +3,12 @@
 module ChatSDK
   class Message
     attr_reader :id, :text, :author, :thread_id, :channel_id,
-      :platform, :attachments, :raw, :timestamp
+      :platform, :attachments, :links, :reply_to, :subject, :raw, :timestamp
+    attr_accessor :is_mention
 
     def initialize(id:, text:, author:, thread_id:, channel_id:, platform:,
-      attachments: [], raw: nil, timestamp: nil)
+      attachments: [], links: [], reply_to: nil, subject: nil, raw: nil,
+      timestamp: nil, is_mention: nil)
       @id = id
       @text = text
       @author = author
@@ -14,8 +16,12 @@ module ChatSDK
       @channel_id = channel_id
       @platform = platform
       @attachments = attachments
+      @links = links
+      @reply_to = reply_to
+      @subject = subject
       @raw = raw
       @timestamp = timestamp
+      @is_mention = is_mention
     end
 
     def ==(other)

data/lib/chat_sdk/modals/builder.rb

@@ -32,6 +32,22 @@ module ChatSDK
         @children << ChatSDK::Cards::Node.new(:input, attributes: attrs, children: ctx.nodes)
       end
 
+      def date_input(id:, label:, initial_value: nil, placeholder: nil, optional: false)
+        attrs = {id: id, label: label, input_type: :date, optional: optional}
+        attrs[:initial_value] = initial_value if initial_value
+        attrs[:placeholder] = placeholder if placeholder
+        @children << ChatSDK::Cards::Node.new(:input, attributes: attrs)
+      end
+
+      def number_input(id:, label:, min: nil, max: nil, initial_value: nil, placeholder: nil, decimal: false, optional: false)
+        attrs = {id: id, label: label, input_type: :number, decimal: decimal, optional: optional}
+        attrs[:min] = min unless min.nil?
+        attrs[:max] = max unless max.nil?
+        attrs[:initial_value] = initial_value unless initial_value.nil?
+        attrs[:placeholder] = placeholder if placeholder
+        @children << ChatSDK::Cards::Node.new(:input, attributes: attrs)
+      end
+
       def static_text(content)
         @children << ChatSDK::Cards::Node.new(:text, attributes: {content: content})
       end

data/lib/chat_sdk/postable_message.rb

@@ -2,14 +2,15 @@
 
 module ChatSDK
   class PostableMessage
-    attr_reader :text, :card, :attachments, :metadata
+    attr_reader :text, :card, :attachments, :metadata, :ai_generated
 
-    def initialize(text: nil, card: nil, attachments: [], metadata: {})
+    def initialize(text: nil, card: nil, attachments: [], metadata: {}, ai_generated: false)
       raise ArgumentError, "text or card required" if text.nil? && card.nil?
       @text = text
       @card = card
       @attachments = attachments
       @metadata = metadata
+      @ai_generated = ai_generated
     end
 
     def card?

data/lib/chat_sdk/state/base.rb

@@ -42,6 +42,22 @@ module ChatSDK
       def set_if_absent(key, value, ttl: nil)
         raise NotImplementedError
       end
+
+      def enqueue(key, value, max_size:, drop: :drop_oldest)
+        raise NotImplementedError
+      end
+
+      def drain_queue(key)
+        raise NotImplementedError
+      end
+
+      def queue_depth(key)
+        raise NotImplementedError
+      end
+
+      def extend_lock(key, owner:, ttl:)
+        raise NotImplementedError
+      end
     end
   end
 end

data/lib/chat_sdk/state/memory.rb

@@ -9,6 +9,7 @@ module ChatSDK
         @expirations = {}
         @subscriptions = Set.new
         @locks = {}
+        @queues = {}
       end
 
       def subscribe(thread_id)
@@ -47,6 +48,16 @@ module ChatSDK
         end
       end
 
+      def extend_lock(key, owner:, ttl:)
+        @mutex.synchronize do
+          expire_if_needed(key)
+          return false unless @locks[key] && @locks[key][:owner] == owner
+
+          @locks[key][:expires_at] = Time.now.to_f + ttl
+          true
+        end
+      end
+
       def get(key)
         @mutex.synchronize do
           expire_if_needed(key)
@@ -80,12 +91,32 @@ module ChatSDK
         end
       end
 
+      def enqueue(key, value, max_size:, drop: :drop_oldest)
+        @mutex.synchronize do
+          queue = (@queues[key] ||= [])
+          return queue.length if queue.length >= max_size && drop.to_sym == :drop_newest
+
+          queue << value
+          queue.shift while queue.length > max_size
+          queue.length
+        end
+      end
+
+      def drain_queue(key)
+        @mutex.synchronize { @queues.delete(key) || [] }
+      end
+
+      def queue_depth(key)
+        @mutex.synchronize { Array(@queues[key]).length }
+      end
+
       def clear
         @mutex.synchronize do
           @store.clear
           @expirations.clear
           @subscriptions.clear
           @locks.clear
+          @queues.clear
         end
       end
 

data/lib/chat_sdk/streaming/stream.rb

@@ -3,6 +3,8 @@
 module ChatSDK
   module Streaming
     class Stream
+      include ChatSDK::Adapter::Invocation
+
       attr_reader :adapter, :channel_id, :thread_id, :update_interval
 
       def initialize(adapter:, channel_id:, thread_id:, placeholder: nil, update_interval: 0.5)
@@ -50,10 +52,12 @@ module ChatSDK
         return if @buffer.empty?
 
         if @message_id && adapter.supports?(:edit_messages)
-          adapter.edit_message(
+          call_adapter(
+            :edit_message,
             channel_id: channel_id,
             message_id: @message_id,
-            message: PostableMessage.new(text: @buffer.dup)
+            message: PostableMessage.new(text: @buffer.dup),
+            thread_id: thread_id
           )
         elsif !@message_id
           result = adapter.post_message(