chat_sdk 0.1.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6bcc60c6b4443d14e0afb167cc7a6b8f5bbe60663fd97e275f87435313cf0705
-  data.tar.gz: 4f3820e9f8ae54789a15b89f351e035b942d741d7670accd509adf86e693b4c8
+  metadata.gz: a8db1850adc2b313ad351d222eed5ed588f6c46b122bcf9f6f8f3eba445c19d5
+  data.tar.gz: 5fd507fa0cb224b1e204f5eeaedee74379769f4f9c5a8055af4549ecb1bbc97f
 SHA512:
-  metadata.gz: b60a52d3a1c878b74e57e57ee3ed2b40191f60ce2db45c3c80ec762324f54b738f6d4ea448f362f02f3e0a84026656e55090c1feef4abf96cfe6b67ba2c19675
-  data.tar.gz: f13771e3df25d44835659b04d424b6410eb2c9f8ffd5a53e3aaa24cd111446ca10b53a6f88adccccb6b261a7289597f0ee7c166795b6abb6fe69fccfc2fa7c4d
+  metadata.gz: 8af8ee31c13cbc5acccef41282ad5717ad2b2ff149fed4bcec95bfdb9fc6c422560d4d55c965e992cc1df1194232813b64f62653cc4c158ff51b4226768f871c
+  data.tar.gz: 0d1132b3d7f19f466aeb29c0d5827af6abc7702a917c90b1d679675239d24fda092b7d273830f881dd0b2e9693a1a975b6f3e6f1ff22f4c4652dbb876489915e

data/lib/chat_sdk/ai/converter.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module ChatSDK
+  module AI
+    class Converter
+      ROLE_USER = "user"
+      ROLE_ASSISTANT = "assistant"
+
+      class << self
+        def to_ai_messages(messages, include_names: false, &transform)
+          messages
+            .sort_by { |m| m.timestamp || m.id }
+            .reject { |m| m.text.nil? || m.text.strip.empty? }
+            .filter_map { |m| convert_message(m, include_names: include_names, &transform) }
+        end
+
+        private
+
+        def convert_message(message, include_names: false)
+          role = message.author&.bot? ? ROLE_ASSISTANT : ROLE_USER
+
+          content = message.text
+          if include_names && role == ROLE_USER && message.author
+            content = "[#{message.author.name}]: #{content}"
+          end
+
+          result = {role: role, content: content}
+
+          if message.attachments&.any?
+            parts = [{type: "text", text: content}]
+            message.attachments.each do |att|
+              parts << attachment_to_part(att)
+            end
+            result[:content] = parts
+          end
+
+          result = yield(result, message) if block_given?
+          result
+        end
+
+        def attachment_to_part(attachment)
+          if attachment.is_a?(Hash)
+            mime = attachment[:mime_type] || attachment[:content_type] || "application/octet-stream"
+            if mime.start_with?("image/")
+              {type: "image", url: attachment[:url], media_type: mime}
+            else
+              {type: "file", url: attachment[:url], filename: attachment[:filename], media_type: mime}
+            end
+          else
+            {type: "text", text: attachment.to_s}
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chat_sdk/ai/stream_handler.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module ChatSDK
+  module AI
+    class StreamHandler
+      def self.stream_to_thread(thread, enumerable, placeholder: "Thinking...")
+        thread.post_stream(placeholder: placeholder) do |stream|
+          enumerable.each { |chunk| stream << chunk.to_s }
+        end
+      end
+    end
+  end
+end

data/lib/chat_sdk/ai/tool_builder.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+module ChatSDK
+  module AI
+    class ToolBuilder
+      PRESETS = {
+        reader: %i[fetch_messages fetch_thread],
+        messenger: %i[fetch_messages fetch_thread post_message send_direct_message add_reaction start_typing],
+        moderator: %i[fetch_messages fetch_thread post_message send_direct_message add_reaction
+          edit_message delete_message remove_reaction start_typing]
+      }.freeze
+
+      TOOL_DEFINITIONS = {
+        fetch_messages: {
+          description: "Fetch recent messages from a channel or thread",
+          parameters: {
+            type: "object",
+            properties: {
+              adapter_name: {type: "string", description: "Adapter name (e.g., 'slack', 'teams')"},
+              channel_id: {type: "string", description: "Channel ID"},
+              thread_id: {type: "string", description: "Thread ID (optional)"},
+              limit: {type: "integer", description: "Max messages to fetch", default: 20}
+            },
+            required: %w[adapter_name channel_id]
+          },
+          read_only: true
+        },
+        fetch_thread: {
+          description: "Fetch all messages in a specific thread",
+          parameters: {
+            type: "object",
+            properties: {
+              adapter_name: {type: "string", description: "Adapter name"},
+              channel_id: {type: "string", description: "Channel ID"},
+              thread_id: {type: "string", description: "Thread ID"}
+            },
+            required: %w[adapter_name channel_id thread_id]
+          },
+          read_only: true
+        },
+        post_message: {
+          description: "Post a message to a channel or thread",
+          parameters: {
+            type: "object",
+            properties: {
+              adapter_name: {type: "string", description: "Adapter name"},
+              channel_id: {type: "string", description: "Channel ID"},
+              thread_id: {type: "string", description: "Thread ID (optional, for replies)"},
+              text: {type: "string", description: "Message text (markdown)"}
+            },
+            required: %w[adapter_name channel_id text]
+          },
+          read_only: false
+        },
+        send_direct_message: {
+          description: "Send a direct message to a user",
+          parameters: {
+            type: "object",
+            properties: {
+              adapter_name: {type: "string", description: "Adapter name"},
+              user_id: {type: "string", description: "User ID"},
+              text: {type: "string", description: "Message text"}
+            },
+            required: %w[adapter_name user_id text]
+          },
+          read_only: false
+        },
+        edit_message: {
+          description: "Edit an existing message",
+          parameters: {
+            type: "object",
+            properties: {
+              adapter_name: {type: "string", description: "Adapter name"},
+              channel_id: {type: "string", description: "Channel ID"},
+              message_id: {type: "string", description: "Message ID to edit"},
+              text: {type: "string", description: "New message text"}
+            },
+            required: %w[adapter_name channel_id message_id text]
+          },
+          read_only: false
+        },
+        delete_message: {
+          description: "Delete a message",
+          parameters: {
+            type: "object",
+            properties: {
+              adapter_name: {type: "string", description: "Adapter name"},
+              channel_id: {type: "string", description: "Channel ID"},
+              message_id: {type: "string", description: "Message ID to delete"}
+            },
+            required: %w[adapter_name channel_id message_id]
+          },
+          read_only: false
+        },
+        add_reaction: {
+          description: "Add an emoji reaction to a message",
+          parameters: {
+            type: "object",
+            properties: {
+              adapter_name: {type: "string", description: "Adapter name"},
+              channel_id: {type: "string", description: "Channel ID"},
+              message_id: {type: "string", description: "Message ID"},
+              emoji: {type: "string", description: "Emoji name (e.g., 'thumbsup')"}
+            },
+            required: %w[adapter_name channel_id message_id emoji]
+          },
+          read_only: false
+        },
+        remove_reaction: {
+          description: "Remove an emoji reaction from a message",
+          parameters: {
+            type: "object",
+            properties: {
+              adapter_name: {type: "string", description: "Adapter name"},
+              channel_id: {type: "string", description: "Channel ID"},
+              message_id: {type: "string", description: "Message ID"},
+              emoji: {type: "string", description: "Emoji name"}
+            },
+            required: %w[adapter_name channel_id message_id emoji]
+          },
+          read_only: false
+        },
+        start_typing: {
+          description: "Show typing indicator in a channel",
+          parameters: {
+            type: "object",
+            properties: {
+              adapter_name: {type: "string", description: "Adapter name"},
+              channel_id: {type: "string", description: "Channel ID"},
+              thread_id: {type: "string", description: "Thread ID (optional)"}
+            },
+            required: %w[adapter_name channel_id]
+          },
+          read_only: false
+        }
+      }.freeze
+
+      def initialize(preset: :messenger, require_approval: true)
+        @preset = preset.to_sym
+        @require_approval = require_approval
+        raise ChatSDK::ConfigurationError, "Unknown preset: #{@preset}" unless PRESETS.key?(@preset)
+      end
+
+      def build
+        tool_names = PRESETS[@preset]
+        tool_names.each_with_object({}) do |name, tools|
+          defn = TOOL_DEFINITIONS[name].dup
+          defn[:requires_approval] = @require_approval && !defn[:read_only]
+          tools[name] = defn
+        end
+      end
+    end
+  end
+end

data/lib/chat_sdk/ai/tool_executor.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module ChatSDK
+  module AI
+    class ToolExecutor
+      def initialize(chat:)
+        @chat = chat
+      end
+
+      def execute(tool_name, arguments)
+        tool_name = tool_name.to_sym
+        raise ChatSDK::Error, "Unknown tool: #{tool_name}" unless ToolBuilder::TOOL_DEFINITIONS.key?(tool_name)
+
+        args = arguments.transform_keys(&:to_sym)
+        adapter_name = args[:adapter_name].to_sym
+
+        send(:"execute_#{tool_name}", adapter_name, args)
+      end
+
+      private
+
+      def execute_fetch_messages(adapter_name, args)
+        channel = @chat.channel(args[:channel_id], adapter_name: adapter_name)
+        messages, _cursor = channel.adapter.fetch_messages(
+          channel_id: args[:channel_id],
+          thread_id: args[:thread_id],
+          limit: args[:limit] || 20
+        )
+        serialize_messages(messages)
+      end
+
+      def execute_fetch_thread(adapter_name, args)
+        channel = @chat.channel(args[:channel_id], adapter_name: adapter_name)
+        messages, _cursor = channel.adapter.fetch_messages(
+          channel_id: args[:channel_id],
+          thread_id: args[:thread_id]
+        )
+        serialize_messages(messages)
+      end
+
+      def execute_post_message(adapter_name, args)
+        channel = @chat.channel(args[:channel_id], adapter_name: adapter_name)
+        if args[:thread_id]
+          thread = channel.thread(args[:thread_id])
+          result = thread.post(args[:text])
+        else
+          result = channel.post(args[:text])
+        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])
+        {id: result.id, channel_id: dm_channel.id}
+      end
+
+      def execute_edit_message(adapter_name, args)
+        thread = @chat.channel(args[:channel_id], adapter_name: adapter_name).thread(args[:channel_id])
+        thread.edit(args[:message_id], args[:text])
+        {success: true}
+      end
+
+      def execute_delete_message(adapter_name, args)
+        thread = @chat.channel(args[:channel_id], adapter_name: adapter_name).thread(args[:channel_id])
+        thread.delete(args[:message_id])
+        {success: true}
+      end
+
+      def execute_add_reaction(adapter_name, args)
+        thread = @chat.channel(args[:channel_id], adapter_name: adapter_name).thread(args[:channel_id])
+        thread.react(args[:message_id], args[:emoji])
+        {success: true}
+      end
+
+      def execute_remove_reaction(adapter_name, args)
+        thread = @chat.channel(args[:channel_id], adapter_name: adapter_name).thread(args[:channel_id])
+        thread.unreact(args[:message_id], args[:emoji])
+        {success: true}
+      end
+
+      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])
+        {success: true}
+      end
+
+      def serialize_messages(messages)
+        messages.map { |m| {id: m.id, text: m.text, author: m.author&.name, timestamp: m.timestamp} }
+      end
+    end
+  end
+end

data/lib/chat_sdk/ai.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module ChatSDK
+  module AI
+    class << self
+      def to_ai_messages(messages, include_names: false, &transform)
+        Converter.to_ai_messages(messages, include_names: include_names, &transform)
+      end
+
+      def create_tools(chat:, preset: :messenger, require_approval: true)
+        ToolBuilder.new(chat: chat, preset: preset, require_approval: require_approval).build
+      end
+    end
+  end
+end

data/lib/chat_sdk/cards/node.rb

@@ -25,14 +25,10 @@ module ChatSDK
       def collect_text(nodes = [self])
         nodes.flat_map do |node|
           case node.type
-          when :card
-            collect_text(node.children)
           when :text
             [node.attributes[:content]]
           when :field
             ["#{node.attributes[:label]}: #{node.attributes[:value]}"]
-          when :section
-            collect_text(node.children)
           when :button, :link_button
             [node.attributes[:text]]
           else

data/lib/chat_sdk/dispatcher.rb

@@ -60,27 +60,13 @@ module ChatSDK
       lock_key = "chat_sdk:lock:#{thread_key}"
       return true if @state.acquire_lock(lock_key, owner: lock_owner, ttl: 30)
 
-      case @config.on_lock_conflict
-      when :drop
-        ChatSDK::Log.debug("Lock conflict, dropping event for #{thread_key}")
-        false
-      when :force
-        @state.force_lock(lock_key, owner: lock_owner, ttl: 30)
-        true
-      else
-        if @config.on_lock_conflict.respond_to?(:call)
-          policy = @config.on_lock_conflict.call(thread_key, event)
-          case policy
-          when :force
-            @state.force_lock(lock_key, owner: lock_owner, ttl: 30)
-            true
-          else
-            false
-          end
-        else
-          false
-        end
-      end
+      policy = @config.on_lock_conflict
+      policy = policy.call(thread_key, event) if policy.respond_to?(:call)
+
+      return false unless policy == :force
+
+      @state.force_lock(lock_key, owner: lock_owner, ttl: 30)
+      true
     end
 
     def release_lock(thread_key)
@@ -109,10 +95,7 @@ module ChatSDK
     end
 
     def add_thread_to_event(event, thread)
-      event.instance_variable_set(:@thread, thread)
-      unless event.respond_to?(:thread)
-        event.define_singleton_method(:thread) { @thread }
-      end
+      event.thread = thread if event.respond_to?(:thread=)
     end
   end
 end

data/lib/chat_sdk/events/action.rb

@@ -4,6 +4,7 @@ module ChatSDK
   module Events
     class Action < Base
       attr_reader :action_id, :value, :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)
         super(type: :action, **kwargs)

data/lib/chat_sdk/events/reaction.rb

@@ -4,6 +4,7 @@ module ChatSDK
   module Events
     class Reaction < Base
       attr_reader :emoji, :user_id, :message_id, :thread_id, :channel_id, :added
+      attr_accessor :thread
 
       def initialize(emoji:, user_id:, message_id:, thread_id:, channel_id:, added: true, **kwargs)
         super(type: :reaction, **kwargs)

data/lib/chat_sdk/events/slash_command.rb

@@ -4,6 +4,7 @@ module ChatSDK
   module Events
     class SlashCommand < Base
       attr_reader :command, :text, :user_id, :channel_id, :trigger_id
+      attr_accessor :thread
 
       def initialize(command:, user_id:, channel_id:, text: "", trigger_id: nil, **kwargs)
         super(type: :slash_command, **kwargs)

data/lib/chat_sdk/thread.rb

@@ -61,6 +61,10 @@ module ChatSDK
       adapter.remove_reaction(channel_id: channel_id, message_id: message_id, emoji: emoji)
     end
 
+    def post_ai_stream(enumerable, placeholder: "Thinking...")
+      ChatSDK::AI::StreamHandler.stream_to_thread(self, enumerable, placeholder: placeholder)
+    end
+
     def upload(io:, filename:, comment: nil)
       adapter.upload_file(channel_id: channel_id, io: io, filename: filename, thread_id: id, comment: comment)
     end

data/lib/chat_sdk/version.rb

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

data/lib/chat_sdk.rb

@@ -9,7 +9,7 @@ module ChatSDK
     def loader
       @loader ||= begin
         loader = Zeitwerk::Loader.for_gem(warn_on_extra_files: false)
-        loader.inflector.inflect("chat_sdk" => "ChatSDK")
+        loader.inflector.inflect("chat_sdk" => "ChatSDK", "ai" => "AI")
         loader.ignore("#{__dir__}/chat_sdk/version.rb")
         loader.ignore("#{__dir__}/chat_sdk/errors.rb")
         loader.setup

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: chat_sdk
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Rootly
@@ -34,6 +34,11 @@ files:
 - lib/chat_sdk.rb
 - lib/chat_sdk/adapter/base.rb
 - lib/chat_sdk/adapter/capabilities.rb
+- lib/chat_sdk/ai.rb
+- lib/chat_sdk/ai/converter.rb
+- lib/chat_sdk/ai/stream_handler.rb
+- lib/chat_sdk/ai/tool_builder.rb
+- lib/chat_sdk/ai/tool_executor.rb
 - lib/chat_sdk/author.rb
 - lib/chat_sdk/cards/actions_context.rb
 - lib/chat_sdk/cards/builder.rb