chat_sdk 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 36c07ba6e29c7d1cf858767caca271826418d829547426f1677a32c94133205e
-  data.tar.gz: 0a00e35abebb7f43b8c9bb68576fce634d46088430029b33ad7f63c2d3820bbb
+  metadata.gz: dc45b8149b772db87ae0793f070a3f068353ef09a177d59c3526eb0ec37d1fb9
+  data.tar.gz: 16eb68d587eb53a43337f22dd2cd7d5b564383d892ecda9b64b77b5ae45a05a0
 SHA512:
-  metadata.gz: 5483b777f81c28e3e367f84d0e4a3413b8f7d60ff09036d6148a3e565a5287252660e0fcc2aa3e7cce6c0d2f607f7a4834514f7f4da66445c1a6728ebc1a0ff6
-  data.tar.gz: b2650d632171a42556aab7d6df09d5b6c79e7cfd1a032b9806a5d49b65892c3c62435d22463a24d382904df03c02b81eb3e93d5f86b0b83570e5ff24f9bb88a8
+  metadata.gz: 7a6cb0121846bf8a75b849f0d6bedfc48601c738dba99c3ad838ecdcb3b31fd7b4a27cd16bfa75cee66a4f70e62b62ae1c4730546b22f430e72d1af1bf6219c2
+  data.tar.gz: 602d33c5bba332dac427d61e8566c396f10c057e6b17a3422d1ab4846e4d7e8857ece123b50d2d357e310072f119bee00436db593e6138e46aabc34ba65f777c

data/lib/chat_sdk/adapter/base.rb

@@ -22,6 +22,10 @@ module ChatSDK
         nil
       end
 
+      def webhook_response(_events)
+        nil
+      end
+
       def parse_events(rack_request)
         raise NotImplementedError
       end
@@ -41,12 +45,12 @@ module ChatSDK
         raise NotImplementedError
       end
 
-      def edit_message(channel_id:, message_id:, message:)
+      def edit_message(channel_id:, message_id:, message:, thread_id: nil)
         require_capability!(:edit_messages)
         raise NotImplementedError
       end
 
-      def delete_message(channel_id:, message_id:)
+      def delete_message(channel_id:, message_id:, thread_id: nil)
         require_capability!(:delete_messages)
         raise NotImplementedError
       end
@@ -61,12 +65,12 @@ module ChatSDK
         raise NotImplementedError
       end
 
-      def add_reaction(channel_id:, message_id:, emoji:)
+      def add_reaction(channel_id:, message_id:, emoji:, thread_id: nil)
         require_capability!(:reactions)
         raise NotImplementedError
       end
 
-      def remove_reaction(channel_id:, message_id:, emoji:)
+      def remove_reaction(channel_id:, message_id:, emoji:, thread_id: nil)
         require_capability!(:reactions)
         raise NotImplementedError
       end
@@ -96,11 +100,15 @@ module ChatSDK
         raise NotImplementedError
       end
 
-      def start_typing(channel_id:, thread_id: nil)
+      def start_typing(channel_id:, thread_id: nil, message_id: nil)
         require_capability!(:typing_indicator)
         raise NotImplementedError
       end
 
+      def concurrency_scope(_event)
+        nil
+      end
+
       def mention(user_id)
         raise NotImplementedError
       end

data/lib/chat_sdk/adapter/invocation.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module ChatSDK
+  module Adapter
+    module Invocation
+      private
+
+      def call_adapter(method_name, **kwargs)
+        params = adapter.method(method_name).parameters
+        accepts_thread_id = params.any? do |type, name|
+          type == :keyrest || (%i[key keyreq].include?(type) && name == :thread_id)
+        end
+        kwargs.delete(:thread_id) unless accepts_thread_id
+        adapter.public_send(method_name, **kwargs)
+      end
+    end
+  end
+end

data/lib/chat_sdk/ai/conversation_scope.rb

@@ -4,29 +4,39 @@ module ChatSDK
   module AI
     module ConversationScope
       THREAD_KEY = :chat_sdk_ai_conversation_scope
+      ACTIVE_KEY = :chat_sdk_ai_conversation_scope_active
 
       class << self
         def current
           ::Thread.current[THREAD_KEY]
         end
 
+        def active?
+          !!::Thread.current[ACTIVE_KEY]
+        end
+
         def with(thread)
           previous = current
+          previous_active = active?
           ::Thread.current[THREAD_KEY] = scope_for(thread)
+          ::Thread.current[ACTIVE_KEY] = true
           yield
         ensure
           ::Thread.current[THREAD_KEY] = previous
+          ::Thread.current[ACTIVE_KEY] = previous_active
         end
 
         def scope_for(value)
           return if value.nil?
           return value.transform_keys(&:to_sym) if value.is_a?(Hash)
 
-          {
+          scope = {
             adapter_name: value.adapter.name.to_sym,
             channel_id: value.respond_to?(:channel_id) ? value.channel_id.to_s : value.id.to_s,
             thread_id: value.is_a?(ChatSDK::Thread) ? value.id.to_s : nil
           }
+          scope[:message_id] = value.current_message.id if value.respond_to?(:current_message) && value.current_message
+          scope
         end
       end
     end

data/lib/chat_sdk/ai/tool_builder.rb

@@ -131,7 +131,8 @@ module ChatSDK
             properties: {
               adapter_name: {type: "string", description: "Adapter name"},
               channel_id: {type: "string", description: "Channel ID"},
-              thread_id: {type: "string", description: "Thread ID (optional)"}
+              thread_id: {type: "string", description: "Thread ID (optional)"},
+              message_id: {type: "string", description: "Current message ID (optional)"}
             },
             required: %w[adapter_name channel_id]
           },

data/lib/chat_sdk/ai/tool_executor.rb

@@ -5,13 +5,11 @@ module ChatSDK
     class ToolExecutor
       def initialize(chat:, scope: nil, strict_scope: false)
         @chat = chat
-        @scope = if scope == false
-          false
-        else
-          ConversationScope.scope_for(scope) || ConversationScope.current&.dup
-        end
+        @scope = (scope == false) ? false : (ConversationScope.scope_for(scope) || ConversationScope.current&.dup)
+        @created_in_handler = ConversationScope.active?
+        validate_scope!(@scope) if @scope
         @strict_scope = strict_scope
-        @warned_unscoped = false
+        @warned_unscoped = {}
       end
 
       def execute(tool_name, arguments)
@@ -20,7 +18,7 @@ module ChatSDK
 
         args = arguments.transform_keys(&:to_sym)
         adapter_name = args[:adapter_name].to_sym
-        guard_scope!(adapter_name, args) unless tool_name == :send_direct_message
+        guard_scope!(tool_name, adapter_name, args)
 
         send(:"execute_#{tool_name}", adapter_name, args)
       end
@@ -48,24 +46,25 @@ module ChatSDK
 
       def execute_post_message(adapter_name, args)
         channel = @chat.channel(args[:channel_id], adapter_name: adapter_name)
+        message = ChatSDK::PostableMessage.new(text: args[:text], ai_generated: true)
         if args[:thread_id]
           thread = channel.thread(args[:thread_id])
-          result = thread.post(args[:text])
+          result = thread.post(message)
         else
-          result = channel.post(args[:text])
+          result = channel.post(message)
         end
         {id: result.id, text: args[:text]}
       end
 
       def execute_send_direct_message(adapter_name, args)
         dm_channel = @chat.open_dm(args[:user_id], adapter_name: adapter_name)
-        result = dm_channel.post(args[:text])
+        result = dm_channel.post(ChatSDK::PostableMessage.new(text: args[:text], ai_generated: true))
         {id: result.id, channel_id: dm_channel.id}
       end
 
       def execute_edit_message(adapter_name, args)
         thread = target_thread(adapter_name, args)
-        thread.edit(args[:message_id], args[:text])
+        thread.edit(args[:message_id], ChatSDK::PostableMessage.new(text: args[:text], ai_generated: true))
         {success: true}
       end
 
@@ -89,7 +88,9 @@ module ChatSDK
 
       def execute_start_typing(adapter_name, args)
         adapter = @chat.adapter(adapter_name)
-        adapter.start_typing(channel_id: args[:channel_id], thread_id: args[:thread_id])
+        scoped_message_id = @scope.is_a?(Hash) ? @scope[:message_id] : nil
+        message_id = args[:message_id] || ConversationScope.current&.[](:message_id) || scoped_message_id
+        adapter.start_typing(channel_id: args[:channel_id], thread_id: args[:thread_id], message_id: message_id)
         {success: true}
       end
 
@@ -102,18 +103,25 @@ module ChatSDK
         channel.thread(args[:thread_id] || args[:channel_id])
       end
 
-      def guard_scope!(adapter_name, args)
+      def guard_scope!(tool_name, adapter_name, args)
         return if @scope == false
 
         scope = @scope || ConversationScope.current
         unless scope
-          unless @warned_unscoped
+          if ConversationScope.active? || @created_in_handler
+            raise ChatSDK::Error, "AI tool call requires an explicit scope when run inside a handler without a conversation"
+          end
+
+          unless @warned_unscoped[tool_name]
             ChatSDK::Log.warn("AI tool ran without a conversation scope; pass scope: to create_executor to confine access")
-            @warned_unscoped = true
+            @warned_unscoped[tool_name] = true
           end
+
           return
         end
 
+        return if tool_name == :send_direct_message
+
         target_channel = args[:channel_id].to_s
         target_thread = args[:thread_id]&.to_s
         same_channel = adapter_name == scope.fetch(:adapter_name).to_sym && target_channel == scope.fetch(:channel_id).to_s
@@ -125,6 +133,15 @@ module ChatSDK
         active = [scope[:adapter_name], scope[:channel_id], scope[:thread_id]].compact.join(":")
         raise ChatSDK::Error, "AI tool call blocked: executor is scoped to #{active.inspect}, but targeted #{target.inspect}"
       end
+
+      def validate_scope!(scope)
+        %i[channel_id thread_id].each do |key|
+          next if key == :thread_id && scope[key].nil?
+          next unless scope.key?(key) && scope[key].to_s.empty?
+
+          raise ChatSDK::ConfigurationError, "AI tool scope #{key} must not be empty"
+        end
+      end
     end
   end
 end

data/lib/chat_sdk/author.rb

@@ -4,11 +4,12 @@ module ChatSDK
   class Author
     attr_reader :id, :name, :platform, :locale, :email, :raw
 
-    def initialize(id:, name:, platform:, bot: false, system: false, locale: nil, email: nil, raw: nil)
+    def initialize(id:, name:, platform:, bot: false, me: false, system: false, locale: nil, email: nil, raw: nil)
       @id = id
       @name = name
       @platform = platform
       @bot = bot
+      @me = !!me
       @system = system
       @locale = locale
       @email = email
@@ -19,6 +20,10 @@ module ChatSDK
       @bot
     end
 
+    def me?
+      @me
+    end
+
     def system?
       @system
     end

data/lib/chat_sdk/cards/actions_context.rb

@@ -9,18 +9,20 @@ module ChatSDK
         @nodes = []
       end
 
-      def button(text, id:, style: nil, value: nil, tooltip: nil)
+      def button(text, id:, style: nil, value: nil, tooltip: nil, visible_to: nil)
         attrs = {text: text, id: id}
         attrs[:style] = style if style
         attrs[:value] = value if value
         attrs[:tooltip] = tooltip if tooltip
+        attrs[:visible_to] = visible_to if visible_to
         @nodes << Node.new(:button, attributes: attrs)
       end
 
-      def link_button(text, url:, id: nil, tooltip: nil)
+      def link_button(text, url:, id: nil, tooltip: nil, visible_to: nil)
         attrs = {text: text, url: url}
         attrs[:id] = id if id
         attrs[:tooltip] = tooltip if tooltip
+        attrs[:visible_to] = visible_to if visible_to
         @nodes << Node.new(:link_button, attributes: attrs)
       end
 

data/lib/chat_sdk/cards/builder.rb

@@ -3,6 +3,8 @@
 module ChatSDK
   module Cards
     class Builder
+      RESERVED_TEXT_INPUT_IDS = %w[actionId value msteams].freeze
+
       def initialize(title: nil, subtitle: nil, width: nil, &block)
         @title = title
         @subtitle = subtitle
@@ -31,6 +33,17 @@ module ChatSDK
         @children << Node.new(:image, attributes: {url: url, alt: alt})
       end
 
+      def text_input(id:, label:, placeholder: nil, multiline: false, optional: false, value: nil)
+        if RESERVED_TEXT_INPUT_IDS.include?(id.to_s)
+          raise ArgumentError, "Text input id #{id.inspect} is reserved"
+        end
+
+        attrs = {id: id, label: label, multiline: multiline, optional: optional}
+        attrs[:placeholder] = placeholder if placeholder
+        attrs[:value] = value unless value.nil?
+        @children << Node.new(:text_input, attributes: attrs)
+      end
+
       def fields(&block)
         ctx = FieldsContext.new
         ctx.instance_eval(&block)
@@ -50,11 +63,15 @@ module ChatSDK
         @children << Node.new(:actions, children: ctx.nodes)
       end
 
-      def table(headers:, rows:, align: nil, caption: nil, page_size: nil)
+      def table(headers:, rows:, align: nil, caption: nil, page_size: nil, widths: nil, grid_lines: nil, grid_style: nil, vertical_align: nil)
         attrs = {headers: headers, rows: rows}
         attrs[:align] = align if align
         attrs[:caption] = caption if caption
         attrs[:page_size] = page_size if page_size
+        attrs[:widths] = widths if widths
+        attrs[:grid_lines] = grid_lines unless grid_lines.nil?
+        attrs[:grid_style] = grid_style if grid_style
+        attrs[:vertical_align] = vertical_align if vertical_align
         @children << Node.new(:table, attributes: attrs)
       end
 

data/lib/chat_sdk/cards/node.rb

@@ -31,6 +31,8 @@ module ChatSDK
             ["#{node.attributes[:label]}: #{node.attributes[:value]}"]
           when :button, :link_button
             [node.attributes[:text]]
+          when :text_input
+            [node.attributes[:label]]
           when :table
             table_text(node)
           when :chart

data/lib/chat_sdk/cards/renderer.rb

@@ -15,6 +15,7 @@ module ChatSDK
         when :actions then render_actions(node)
         when :button then "[#{node.attributes[:text]}]"
         when :link_button then "[#{node.attributes[:text]}](#{node.attributes[:url]})"
+        when :text_input then node.attributes[:label]
         when :select then "_#{node.attributes[:placeholder] || "Select"}_"
         when :table then render_table(node)
         when :chart then render_chart(node)

data/lib/chat_sdk/chat.rb

@@ -8,6 +8,7 @@ module ChatSDK
       @config = Config.new(user_name: user_name, adapters: adapters, state: state, **options)
       @state = state
       @adapters = adapters
+      @adapters.each_value { |adapter| adapter.set_state(state) if adapter.respond_to?(:set_state) }
       @registry = EventRegistry.new
       @history = History.new(self)
       @webhooks = {}
@@ -26,7 +27,12 @@ module ChatSDK
     end
 
     def on_new_message(pattern = nil, &block)
-      @registry.register(:mention, matcher: pattern, &block)
+      unless pattern.nil? || pattern.is_a?(Regexp)
+        raise ChatSDK::ConfigurationError, "on_new_message pattern must be a Regexp or nil"
+      end
+      raise ChatSDK::ConfigurationError, "on_new_message requires a block" unless block
+
+      @registry.register(:new_message, matcher: pattern, &block)
     end
 
     def on_direct_message(&block)
@@ -53,6 +59,14 @@ module ChatSDK
       @registry.register(:slash_command, matcher: command, &block)
     end
 
+    def on_installed(&block)
+      @registry.register(:installed, &block)
+    end
+
+    def on_uninstalled(&block)
+      @registry.register(:uninstalled, &block)
+    end
+
     # Adapter access
     def adapter(name)
       @adapters.fetch(name) { raise ChatSDK::ConfigurationError, "Unknown adapter: #{name}" }

data/lib/chat_sdk/dispatcher.rb

@@ -27,10 +27,11 @@ module ChatSDK
           return execute_event(event, build_thread(event, adapter))
         end
 
-        return unless dedupe(event, adapter_name)
+        concurrency_scope = adapter.concurrency_scope(event)
+        return unless dedupe(event, adapter_name, concurrency_scope)
 
         thread = build_thread(event, adapter)
-        thread_key = thread_key_for(event, adapter_name)
+        thread_key = thread_key_for(event, adapter_name, concurrency_scope)
         strategy = @config.concurrency[:strategy]
 
         if strategy == :concurrent
@@ -155,12 +156,12 @@ module ChatSDK
       end
     end
 
-    def dedupe(event, adapter_name)
+    def dedupe(event, adapter_name, concurrency_scope)
       event_id = extract_event_id(event)
       return true unless event_id
 
       is_new = @state.set_if_absent(
-        "chat_sdk:dedupe:#{adapter_name}:#{event_id}",
+        dedupe_key(adapter_name, concurrency_scope, event_id),
         true,
         ttl: @config.dedupe_ttl
       )
@@ -178,12 +179,18 @@ module ChatSDK
       end
     end
 
-    def thread_key_for(event, adapter_name)
+    def dedupe_key(adapter_name, concurrency_scope, event_id)
+      prefix = ["chat_sdk:dedupe", adapter_name]
+      prefix << concurrency_scope if concurrency_scope
+      "#{prefix.join(":")}:#{event_id}"
+    end
+
+    def thread_key_for(event, adapter_name, concurrency_scope)
       channel_id = event.respond_to?(:channel_id) ? event.channel_id : nil
       thread_id = event.respond_to?(:thread_id) ? event.thread_id : nil
       lock_scope = @config.concurrency[:lock_scope]
       scope_id = (lock_scope&.to_sym == :channel) ? channel_id : thread_id
-      "#{adapter_name}:#{channel_id}:#{scope_id}"
+      [adapter_name, concurrency_scope, channel_id, scope_id].compact.join(":")
     end
 
     def acquire_lock(thread_key, event, owner, force: false, apply_conflict_policy: true)
@@ -256,20 +263,67 @@ module ChatSDK
     end
 
     def execute_event(event, thread, context: nil)
+      if %i[mention subscribed_message direct_message].include?(event.type)
+        route_message_event(event, thread, context)
+        return
+      end
+
       @registry.handlers_for(event).each do |handler|
         execute_handler(handler, event, thread, context: context)
       end
     end
 
+    def route_message_event(event, thread, context)
+      message = event.message
+      dm_handlers = @registry.handlers_for_type(:direct_message, event: event)
+      if event.type == :direct_message && dm_handlers.any?
+        run_handlers(dm_handlers, event, thread, context)
+        return
+      end
+
+      message.is_mention = true if event.type == :direct_message
+
+      if thread&.subscribed?
+        run_handlers(@registry.handlers_for_type(:subscribed_message, event: event), event, thread, context)
+        return
+      end
+
+      if message.is_mention.nil?
+        message.is_mention = if event.type == :mention
+          true
+        else
+          detect_mention(message.text)
+        end
+      end
+
+      if message.is_mention
+        run_handlers(@registry.handlers_for_type(:mention, event: event), event, thread, context)
+        return
+      end
+
+      @registry.handlers_for_type(:new_message, event: event).each do |handler|
+        execute_handler(handler, event, thread, context: context)
+      end
+    end
+
+    def run_handlers(handlers, event, thread, context)
+      handlers.each { |handler| execute_handler(handler, event, thread, context: context) }
+    end
+
+    def detect_mention(text)
+      masked_text = ChatSDK::Format::Mentions.mask_code_spans(text)
+      /(?<![[:word:]])@#{Regexp.escape(@config.user_name)}\b/i.match?(masked_text)
+    end
+
     def execute_handler(handler, event, thread, context: nil)
       ChatSDK::Instrumentation.instrument("handler.chat_sdk", handler_type: event.type) do
         ChatSDK::AI::ConversationScope.with(thread) do
           case event.type
-          when :mention, :subscribed_message, :direct_message
+          when :mention, :subscribed_message, :direct_message, :new_message
             handler.block.call(thread, event.message, context)
           when :message_updated
             handler.block.call(thread, event.message, event.previous_message)
-          when :reaction, :action, :slash_command, :message_deleted
+          when :reaction, :action, :slash_command, :message_deleted, :installed, :uninstalled
             add_thread_to_event(event, thread)
             handler.block.call(event)
           end

data/lib/chat_sdk/event_registry.rb

@@ -13,13 +13,18 @@ module ChatSDK
     end
 
     def handlers_for(event)
-      @handlers.select { |h| matches?(h, event) }
+      handlers_for_type(event.type, event: event)
+    end
+
+    def handlers_for_type(type, event: nil)
+      @handlers.select do |handler|
+        handler.type == type && (!event || matches?(handler, event))
+      end
     end
 
     private
 
     def matches?(handler, event)
-      return false unless handler.type == event.type
       return true if handler.matcher.nil?
 
       case handler.matcher

data/lib/chat_sdk/event_serializer.rb

@@ -21,9 +21,18 @@ module ChatSDK
         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, "user" => dump_author(event.user), "trigger_id" => event.trigger_id)
+          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
@@ -55,10 +64,27 @@ module ChatSDK
         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"], user: load_author(data["user"]), trigger_id: data["trigger_id"], **common)
+          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
@@ -93,7 +119,8 @@ module ChatSDK
           "reply_to" => dump_message(message.reply_to),
           "subject" => json_safe(message.subject),
           "raw" => json_safe(message.raw),
-          "timestamp" => message.timestamp&.iso8601
+          "timestamp" => message.timestamp&.iso8601,
+          "is_mention" => message.is_mention
         }
       end
 
@@ -113,7 +140,8 @@ module ChatSDK
           reply_to: load_message(data["reply_to"]),
           subject: data["subject"],
           raw: data["raw"],
-          timestamp: parse_time(data["timestamp"])
+          timestamp: parse_time(data["timestamp"]),
+          is_mention: data["is_mention"]
         )
       end
 
@@ -125,6 +153,7 @@ module ChatSDK
           "name" => author.name,
           "platform" => author.platform.to_s,
           "bot" => author.bot?,
+          "me" => author.me?,
           "system" => author.system?,
           "locale" => author.locale,
           "email" => author.email,
@@ -141,6 +170,7 @@ module ChatSDK
           name: data["name"],
           platform: data["platform"].to_sym,
           bot: data["bot"],
+          me: data["me"],
           system: data["system"],
           locale: data["locale"],
           email: data["email"],

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/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/message.rb

@@ -4,9 +4,11 @@ module ChatSDK
   class Message
     attr_reader :id, :text, :author, :thread_id, :channel_id,
       :platform, :attachments, :links, :reply_to, :subject, :raw, :timestamp
+    attr_accessor :is_mention
 
     def initialize(id:, text:, author:, thread_id:, channel_id:, platform:,
-      attachments: [], links: [], reply_to: nil, subject: nil, raw: nil, timestamp: nil)
+      attachments: [], links: [], reply_to: nil, subject: nil, raw: nil,
+      timestamp: nil, is_mention: nil)
       @id = id
       @text = text
       @author = author
@@ -19,6 +21,7 @@ module ChatSDK
       @subject = subject
       @raw = raw
       @timestamp = timestamp
+      @is_mention = is_mention
     end
 
     def ==(other)

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/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(

data/lib/chat_sdk/testing/fake_adapter.rb

@@ -50,7 +50,7 @@ module ChatSDK
         )
       end
 
-      def edit_message(channel_id:, message_id:, message:)
+      def edit_message(channel_id:, message_id:, message:, **_options)
         record = RecordedCall.new(:edit_message, channel_id: channel_id, message_id: message_id, message: message)
         @edited_messages << record
         record
@@ -68,7 +68,7 @@ module ChatSDK
         record
       end
 
-      def delete_message(channel_id:, message_id:)
+      def delete_message(channel_id:, message_id:, **_options)
         record = RecordedCall.new(:delete_message, channel_id: channel_id, message_id: message_id)
         @deleted_messages << record
         record
@@ -86,13 +86,13 @@ module ChatSDK
         record
       end
 
-      def add_reaction(channel_id:, message_id:, emoji:)
+      def add_reaction(channel_id:, message_id:, emoji:, **_options)
         record = RecordedCall.new(:add_reaction, channel_id: channel_id, message_id: message_id, emoji: emoji)
         @reactions_added << record
         record
       end
 
-      def remove_reaction(channel_id:, message_id:, emoji:)
+      def remove_reaction(channel_id:, message_id:, emoji:, **_options)
         record = RecordedCall.new(:remove_reaction, channel_id: channel_id, message_id: message_id, emoji: emoji)
         @reactions_removed << record
         record
@@ -122,8 +122,8 @@ module ChatSDK
         record
       end
 
-      def start_typing(channel_id:, thread_id: nil)
-        record = RecordedCall.new(:start_typing, channel_id: channel_id, thread_id: thread_id)
+      def start_typing(channel_id:, thread_id: nil, message_id: nil)
+        record = RecordedCall.new(:start_typing, channel_id: channel_id, thread_id: thread_id, message_id: message_id)
         @typing_started << record
         record
       end

data/lib/chat_sdk/thread.rb

@@ -2,6 +2,8 @@
 
 module ChatSDK
   class Thread
+    include Adapter::Invocation
+
     attr_reader :id, :channel_id, :adapter, :chat, :current_message
 
     def initialize(id:, channel_id:, adapter:, chat:, current_message: nil)
@@ -51,6 +53,10 @@ module ChatSDK
       adapter.mark_as_read(channel_id: channel_id, thread_id: id, message_id: message_id, message: target.is_a?(ChatSDK::Message) ? target : nil)
     end
 
+    def start_typing
+      adapter.start_typing(channel_id: channel_id, thread_id: id, message_id: current_message&.id)
+    end
+
     def post_ephemeral(content, user_id:)
       message = PostableMessage.from(content)
       adapter.post_ephemeral(channel_id: channel_id, user_id: user_id, message: message, thread_id: id)
@@ -69,19 +75,19 @@ module ChatSDK
 
     def edit(message_id, content)
       message = PostableMessage.from(content)
-      adapter.edit_message(channel_id: channel_id, message_id: message_id, message: message)
+      call_adapter(:edit_message, channel_id: channel_id, message_id: message_id, message: message, thread_id: id)
     end
 
     def delete(message_id)
-      adapter.delete_message(channel_id: channel_id, message_id: message_id)
+      call_adapter(:delete_message, channel_id: channel_id, message_id: message_id, thread_id: id)
     end
 
     def react(message_id, emoji)
-      adapter.add_reaction(channel_id: channel_id, message_id: message_id, emoji: emoji)
+      call_adapter(:add_reaction, channel_id: channel_id, message_id: message_id, emoji: emoji, thread_id: id)
     end
 
     def unreact(message_id, emoji)
-      adapter.remove_reaction(channel_id: channel_id, message_id: message_id, emoji: emoji)
+      call_adapter(:remove_reaction, channel_id: channel_id, message_id: message_id, emoji: emoji, thread_id: id)
     end
 
     def post_ai_stream(enumerable, placeholder: "Thinking...")

data/lib/chat_sdk/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ChatSDK
-  VERSION = "1.1.0"
+  VERSION = "1.2.0"
 end

data/lib/chat_sdk/webhook/endpoint.rb

@@ -22,6 +22,9 @@ module ChatSDK
         events = adapter.parse_events(request || env)
         events.each { |event| chat.dispatch(event, adapter_name: adapter_name) }
 
+        response = adapter.webhook_response(events)
+        return response if response
+
         [200, {"content-type" => "text/plain"}, [""]]
       rescue ChatSDK::SignatureVerificationError => e
         ChatSDK::Log.warn("Signature verification failed: #{e.message}")

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: chat_sdk
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Quentin Rousseau
@@ -48,6 +48,7 @@ files:
 - lib/chat_sdk.rb
 - lib/chat_sdk/adapter/base.rb
 - lib/chat_sdk/adapter/capabilities.rb
+- lib/chat_sdk/adapter/invocation.rb
 - lib/chat_sdk/adapter/media_types.rb
 - lib/chat_sdk/adapter/meta_verification.rb
 - lib/chat_sdk/ai.rb
@@ -75,13 +76,16 @@ files:
 - lib/chat_sdk/events/action.rb
 - lib/chat_sdk/events/base.rb
 - lib/chat_sdk/events/direct_message.rb
+- lib/chat_sdk/events/installed.rb
 - lib/chat_sdk/events/mention.rb
 - lib/chat_sdk/events/message_deleted.rb
 - lib/chat_sdk/events/message_updated.rb
 - lib/chat_sdk/events/reaction.rb
 - lib/chat_sdk/events/slash_command.rb
 - lib/chat_sdk/events/subscribed_message.rb
+- lib/chat_sdk/events/uninstalled.rb
 - lib/chat_sdk/format/converter.rb
+- lib/chat_sdk/format/mentions.rb
 - lib/chat_sdk/history.rb
 - lib/chat_sdk/instrumentation.rb
 - lib/chat_sdk/log.rb