chat_sdk 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6bcc60c6b4443d14e0afb167cc7a6b8f5bbe60663fd97e275f87435313cf0705
-  data.tar.gz: 4f3820e9f8ae54789a15b89f351e035b942d741d7670accd509adf86e693b4c8
+  metadata.gz: b44dd1b3b15cb4a83647923c0f75ad2208860060010a1e2c47391d1f4b44ca5a
+  data.tar.gz: b6e99a0348c858130e767f6647fa1a430d45e9497e6a7d652343dc4d1e0ef4de
 SHA512:
-  metadata.gz: b60a52d3a1c878b74e57e57ee3ed2b40191f60ce2db45c3c80ec762324f54b738f6d4ea448f362f02f3e0a84026656e55090c1feef4abf96cfe6b67ba2c19675
-  data.tar.gz: f13771e3df25d44835659b04d424b6410eb2c9f8ffd5a53e3aaa24cd111446ca10b53a6f88adccccb6b261a7289597f0ee7c166795b6abb6fe69fccfc2fa7c4d
+  metadata.gz: 4983f6b3a956b5b0cbe2d84c23b739d1ae6f5c8eb34484a42ea9e0f90fe37c0a390a2e0d5bbcf9b7e0a5f993e1395d38d7d830405d67f4de5183918d1bab38e6
+  data.tar.gz: bbd3377c30c6e5fc53e9959a76d96a4eb907743f834b4c4d554317240861d8ab60b85372ab51e911ba720d601abcc6ddb15646053c8409c878f865a141ab3ba6

data/lib/chat_sdk/adapter/base.rb

@@ -89,6 +89,14 @@ module ChatSDK
         Cards::Renderer.new.render(postable_message.card)
       end
 
+      protected
+
+      def read_json_body(rack_request)
+        body = rack_request.body.read
+        rack_request.body.rewind
+        JSON.parse(body)
+      end
+
       private
 
       def require_capability!(cap)

data/lib/chat_sdk/adapter/meta_verification.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "openssl"
+require "rack/utils"
+
+module ChatSDK
+  module Adapter
+    module MetaVerification
+      def verify_meta_signature!(rack_request, secret:, platform_name:)
+        signature = rack_request.get_header("HTTP_X_HUB_SIGNATURE_256")
+
+        unless signature
+          raise ChatSDK::SignatureVerificationError, "Missing #{platform_name} signature header"
+        end
+
+        body = rack_request.body.read
+        rack_request.body.rewind
+
+        expected = "sha256=#{OpenSSL::HMAC.hexdigest("SHA256", secret, body)}"
+
+        unless Rack::Utils.secure_compare(signature, expected)
+          raise ChatSDK::SignatureVerificationError, "Invalid #{platform_name} signature"
+        end
+
+        true
+      end
+
+      def meta_ack_response(rack_request, verify_token:)
+        return nil unless rack_request.get?
+
+        params = rack_request.params
+        mode = params["hub.mode"]
+        token = params["hub.verify_token"]
+        challenge = params["hub.challenge"]
+
+        if mode == "subscribe" && token == verify_token
+          [200, {}, [challenge.to_s]]
+        end
+      end
+    end
+  end
+end

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,19 @@
+# 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(preset: :messenger, require_approval: true)
+        ToolBuilder.new(preset: preset, require_approval: require_approval).build
+      end
+
+      def create_executor(chat:)
+        ToolExecutor.new(chat: chat)
+      end
+    end
+  end
+end

data/lib/chat_sdk/api_client/base.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module ChatSDK
+  module ApiClient
+    class Base
+      MAX_RETRIES = 2
+
+      private
+
+      def connection
+        @connection ||= build_connection { |f| f.request :json }
+      end
+
+      def upload_connection
+        @upload_connection ||= build_connection { |f| f.request :multipart }
+      end
+
+      def build_connection
+        Faraday.new(url: base_url) do |f|
+          yield f
+          configure_auth(f)
+          f.response :json
+          f.adapter :net_http
+        end
+      end
+
+      def base_url
+        raise NotImplementedError
+      end
+
+      def adapter_name
+        raise NotImplementedError
+      end
+
+      def configure_auth(faraday)
+        raise NotImplementedError
+      end
+
+      def resolve_path(path)
+        path
+      end
+
+      def request(method, path, body = nil)
+        retries = 0
+        resolved = resolve_path(path)
+        begin
+          ChatSDK::Instrumentation.instrument("api_request.chat_sdk", adapter: adapter_name, method: method, path: resolved) do
+            response = connection.public_send(method, resolved) do |req|
+              req.body = body if body && method != :get
+            end
+            handle_response(response)
+          end
+        rescue ChatSDK::RateLimitedError => e
+          ChatSDK::Instrumentation.instrument("rate_limited.chat_sdk", adapter: adapter_name, retry_after: e.retry_after, attempt: retries + 1)
+          retries += 1
+          raise if retries > MAX_RETRIES
+          sleep(e.retry_after || (2**retries * 0.5))
+          retry
+        end
+      end
+
+      def handle_response(response)
+        return extract_success_body(response) if response.success?
+
+        body = response.body
+
+        if response.status == 429
+          raise ChatSDK::RateLimitedError.new(
+            "#{adapter_name} API rate limited",
+            retry_after: extract_retry_after(response),
+            status: response.status,
+            body: body,
+            adapter_name: adapter_name
+          )
+        end
+
+        raise ChatSDK::PlatformError.new(
+          "#{adapter_name} API error: #{extract_error_message(response)}",
+          status: response.status,
+          body: body,
+          adapter_name: adapter_name
+        )
+      end
+
+      def extract_success_body(response)
+        body = response.body
+        body.is_a?(Hash) ? body : {}
+      end
+
+      def extract_retry_after(_response)
+        nil
+      end
+
+      def extract_error_message(response)
+        response.status.to_s
+      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/cards/text_helpers.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module ChatSDK
+  module Cards
+    module TextHelpers
+      private
+
+      def collect_text_parts(node)
+        parts = []
+        node.children.each do |child|
+          case child.type
+          when :text
+            parts << child.attributes[:content]
+          when :divider
+            parts << "---"
+          when :fields
+            child.children.each do |field|
+              parts << "#{field.attributes[:label]}: #{field.attributes[:value]}"
+            end
+          when :section
+            parts << child.attributes[:title] if child.attributes[:title]
+            parts.concat(collect_text_parts(child))
+          end
+        end
+        parts
+      end
+
+      def truncate(text, max)
+        return "" unless text
+        (text.length > max) ? "#{text[0..max - 4]}..." : text
+      end
+    end
+  end
+end

data/lib/chat_sdk/dispatcher.rb

@@ -10,18 +10,20 @@ module ChatSDK
     end
 
     def dispatch(event, adapter:, adapter_name:)
-      return unless dedupe(event, adapter_name)
+      ChatSDK::Instrumentation.instrument("dispatch.chat_sdk", adapter: adapter_name, event_type: event.type) do
+        return unless dedupe(event, adapter_name)
 
-      thread = build_thread(event, adapter)
-      thread_key = thread_key_for(event, adapter_name)
+        thread = build_thread(event, adapter)
+        thread_key = thread_key_for(event, adapter_name)
 
-      return unless acquire_lock(thread_key, event)
+        return unless acquire_lock(thread_key, event)
 
-      begin
-        handlers = @registry.handlers_for(event)
-        handlers.each { |handler| execute_handler(handler, event, thread) }
-      ensure
-        release_lock(thread_key)
+        begin
+          handlers = @registry.handlers_for(event)
+          handlers.each { |handler| execute_handler(handler, event, thread) }
+        ensure
+          release_lock(thread_key)
+        end
       end
     end
 
@@ -31,11 +33,13 @@ module ChatSDK
       event_id = extract_event_id(event)
       return true unless event_id
 
-      @state.set_if_absent(
+      is_new = @state.set_if_absent(
         "chat_sdk:dedupe:#{adapter_name}:#{event_id}",
         true,
         ttl: @config.dedupe_ttl
       )
+      ChatSDK::Instrumentation.instrument("dedupe.chat_sdk", adapter: adapter_name, event_id: event_id, duplicate: !is_new)
+      is_new
     end
 
     def extract_event_id(event)
@@ -58,29 +62,20 @@ module ChatSDK
 
     def acquire_lock(thread_key, event)
       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
+      acquired = @state.acquire_lock(lock_key, owner: lock_owner, ttl: 30)
+
+      unless acquired
+        policy = @config.on_lock_conflict
+        policy = policy.call(thread_key, event) if policy.respond_to?(:call)
+
+        if policy == :force
+          @state.force_lock(lock_key, owner: lock_owner, ttl: 30)
+          acquired = true
         end
       end
+
+      ChatSDK::Instrumentation.instrument("lock.chat_sdk", key: thread_key, acquired: acquired, policy: acquired ? nil : policy)
+      acquired
     end
 
     def release_lock(thread_key)
@@ -96,12 +91,14 @@ module ChatSDK
     end
 
     def execute_handler(handler, event, thread)
-      case event.type
-      when :mention, :subscribed_message, :direct_message
-        handler.block.call(thread, event.message)
-      when :reaction, :action, :slash_command
-        add_thread_to_event(event, thread)
-        handler.block.call(event)
+      ChatSDK::Instrumentation.instrument("handler.chat_sdk", handler_type: event.type) do
+        case event.type
+        when :mention, :subscribed_message, :direct_message
+          handler.block.call(thread, event.message)
+        when :reaction, :action, :slash_command
+          add_thread_to_event(event, thread)
+          handler.block.call(event)
+        end
       end
     rescue => e
       ChatSDK::Log.error("Handler error (#{event.type}): #{e.message}")
@@ -109,10 +106,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/instrumentation.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module ChatSDK
+  module Instrumentation
+    @subscribers = Hash.new { |h, k| h[k] = [] }
+    @mutex = Mutex.new
+
+    class << self
+      def subscribe(event_name, &block)
+        @mutex.synchronize { @subscribers[event_name] << block }
+        block
+      end
+
+      def unsubscribe(event_name, block)
+        @mutex.synchronize { @subscribers[event_name].delete(block) }
+      end
+
+      def instrument(event_name, payload = {})
+        listeners = @mutex.synchronize { @subscribers[event_name]&.dup }
+        unless listeners&.any?
+          return yield if block_given?
+
+          return
+        end
+
+        start = monotonic_now
+        result = yield if block_given?
+        payload[:duration] = monotonic_now - start
+        fire(listeners, event_name, payload)
+        result
+      rescue => e
+        payload[:duration] = monotonic_now - start if start
+        payload[:error] = e
+        fire(listeners, event_name, payload) if listeners&.any?
+        raise
+      end
+
+      def reset!
+        @mutex.synchronize { @subscribers.clear }
+      end
+
+      private
+
+      def fire(listeners, event_name, payload)
+        listeners.each { |block| block.call(event_name, payload) }
+      rescue => e
+        ChatSDK::Log.debug("Instrumentation subscriber error: #{e.message}")
+      end
+
+      def monotonic_now
+        Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      end
+    end
+  end
+end

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.3.0"
 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,10 +1,10 @@
 --- !ruby/object:Gem::Specification
 name: chat_sdk
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.3.0
 platform: ruby
 authors:
-- Rootly
+- Quentin Rousseau
 bindir: bin
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
@@ -26,7 +26,7 @@ dependencies:
 description: Platform-agnostic chat bot framework with normalized events, cards DSL,
   streaming, and pluggable adapters
 email:
-- eng@rootly.com
+- quentin@rootly.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -34,6 +34,13 @@ files:
 - lib/chat_sdk.rb
 - lib/chat_sdk/adapter/base.rb
 - lib/chat_sdk/adapter/capabilities.rb
+- lib/chat_sdk/adapter/meta_verification.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/api_client/base.rb
 - lib/chat_sdk/author.rb
 - lib/chat_sdk/cards/actions_context.rb
 - lib/chat_sdk/cards/builder.rb
@@ -41,6 +48,7 @@ files:
 - lib/chat_sdk/cards/node.rb
 - lib/chat_sdk/cards/renderer.rb
 - lib/chat_sdk/cards/select_context.rb
+- lib/chat_sdk/cards/text_helpers.rb
 - lib/chat_sdk/channel.rb
 - lib/chat_sdk/chat.rb
 - lib/chat_sdk/config.rb
@@ -54,6 +62,7 @@ files:
 - lib/chat_sdk/events/reaction.rb
 - lib/chat_sdk/events/slash_command.rb
 - lib/chat_sdk/events/subscribed_message.rb
+- lib/chat_sdk/instrumentation.rb
 - lib/chat_sdk/log.rb
 - lib/chat_sdk/message.rb
 - lib/chat_sdk/modals/builder.rb
@@ -71,7 +80,7 @@ files:
 - lib/chat_sdk/version.rb
 - lib/chat_sdk/webhook/endpoint.rb
 - lib/chat_sdk/webhook/router.rb
-homepage: https://github.com/rootlyhq/rootly-chat-sdk
+homepage: https://github.com/rootlyhq/chat-sdk
 licenses:
 - MIT
 metadata: