chat_sdk-teams 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 405f17761300fe99e9b9546f42d8d418ab56aaa5e26f62fbf719113bf182f40e
+  data.tar.gz: 041c7673256c9d330effed6cc09c75dbfaf88641624b738dd7ea86522820a86d
+SHA512:
+  metadata.gz: a4656f0911cb47d3ac7606f224386e1daa5f51083f69515983236b9fb61163d158425431e14e45ba8cdbc78a8ef89dfed75cc2a195aca09638c02127c7b52d37
+  data.tar.gz: 64e7090b9f5f052bdde73fcb2acc58b8aec6160b30e26c46ad282e7ce9f03fe8e6d64c62e00d740c111b1ca7628424b81d68804e2a285abca43ada713bc3699f

data/lib/chat_sdk/teams/activity_parser.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+module ChatSDK
+  module Teams
+    class ActivityParser
+      class << self
+        def parse(activity, bot_app_id: nil)
+          return [] unless activity.is_a?(Hash)
+
+          case activity["type"]
+          when "message"
+            parse_message(activity, bot_app_id)
+          when "messageReaction"
+            parse_message_reaction(activity)
+          when "invoke"
+            parse_invoke(activity)
+          else
+            []
+          end
+        end
+
+        private
+
+        def parse_message(activity, bot_app_id)
+          return [] if activity.dig("from", "id") == bot_app_id
+
+          author = build_author(activity)
+          conversation_id = activity.dig("conversation", "id")
+          thread_id = activity.dig("conversation", "id")
+
+          message = ChatSDK::Message.new(
+            id: activity["id"],
+            text: activity["text"] || "",
+            author: author,
+            thread_id: thread_id,
+            channel_id: conversation_id,
+            platform: :teams,
+            raw: activity
+          )
+
+          if bot_mentioned?(activity, bot_app_id)
+            [ChatSDK::Events::Mention.new(
+              message: message,
+              thread_id: thread_id,
+              channel_id: conversation_id,
+              platform: :teams,
+              adapter_name: :teams,
+              raw: activity
+            )]
+          elsif activity.dig("conversation", "conversationType") == "personal"
+            [ChatSDK::Events::DirectMessage.new(
+              message: message,
+              thread_id: thread_id,
+              channel_id: conversation_id,
+              platform: :teams,
+              adapter_name: :teams,
+              raw: activity
+            )]
+          else
+            [ChatSDK::Events::SubscribedMessage.new(
+              message: message,
+              thread_id: thread_id,
+              channel_id: conversation_id,
+              platform: :teams,
+              adapter_name: :teams,
+              raw: activity
+            )]
+          end
+        end
+
+        def parse_message_reaction(activity)
+          conversation_id = activity.dig("conversation", "id")
+          events = []
+
+          (activity["reactionsAdded"] || []).each do |reaction|
+            events << ChatSDK::Events::Reaction.new(
+              emoji: reaction["type"],
+              user_id: activity.dig("from", "id"),
+              message_id: activity["replyToId"],
+              thread_id: conversation_id,
+              channel_id: conversation_id,
+              added: true,
+              platform: :teams,
+              adapter_name: :teams,
+              raw: activity
+            )
+          end
+
+          (activity["reactionsRemoved"] || []).each do |reaction|
+            events << ChatSDK::Events::Reaction.new(
+              emoji: reaction["type"],
+              user_id: activity.dig("from", "id"),
+              message_id: activity["replyToId"],
+              thread_id: conversation_id,
+              channel_id: conversation_id,
+              added: false,
+              platform: :teams,
+              adapter_name: :teams,
+              raw: activity
+            )
+          end
+
+          events
+        end
+
+        def parse_invoke(activity)
+          return [] unless activity.dig("value")
+
+          conversation_id = activity.dig("conversation", "id")
+          user = build_author(activity)
+
+          action_id = activity.dig("value", "action") || activity["name"] || "invoke"
+          value = activity.dig("value", "data") || activity["value"]
+          value = value.is_a?(Hash) ? JSON.generate(value) : value.to_s
+
+          [ChatSDK::Events::Action.new(
+            action_id: action_id,
+            value: value,
+            user: user,
+            thread_id: conversation_id,
+            channel_id: conversation_id,
+            platform: :teams,
+            adapter_name: :teams,
+            raw: activity
+          )]
+        end
+
+        def build_author(activity)
+          from = activity["from"] || {}
+          ChatSDK::Author.new(
+            id: from["id"] || "unknown",
+            name: from["name"] || from["id"] || "unknown",
+            platform: :teams,
+            bot: from["role"] == "bot"
+          )
+        end
+
+        def bot_mentioned?(activity, bot_app_id)
+          return false unless bot_app_id
+
+          entities = activity["entities"] || []
+          entities.any? do |entity|
+            entity["type"] == "mention" &&
+              entity.dig("mentioned", "id") == bot_app_id
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chat_sdk/teams/adapter.rb

@@ -0,0 +1,240 @@
+# frozen_string_literal: true
+
+module ChatSDK
+  module Teams
+    class Adapter < ChatSDK::Adapter::Base
+      capabilities :edit_messages, :delete_messages, :threads, :direct_messages,
+        :message_history, :reactions, :file_uploads, :streaming_edit
+
+      attr_reader :client
+
+      def initialize(app_id: nil, app_password: nil, tenant_id: nil)
+        @app_id = app_id || ENV["TEAMS_APP_ID"]
+        @app_password = app_password || ENV["TEAMS_APP_PASSWORD"]
+        @tenant_id = tenant_id || ENV["TEAMS_TENANT_ID"]
+
+        raise ChatSDK::ConfigurationError, "Teams app_id required" unless @app_id
+        raise ChatSDK::ConfigurationError, "Teams app_password required" unless @app_password
+
+        @client = BotFrameworkClient.new(app_id: @app_id, app_password: @app_password)
+        @jwt_verifier = JwtVerifier.new(app_id: @app_id)
+        @renderer = AdaptiveCardRenderer.new
+        @service_urls = {}
+      end
+
+      def name
+        :teams
+      end
+
+      # Inbound
+      def verify_request!(rack_request)
+        auth_header = rack_request.env["HTTP_AUTHORIZATION"]
+        raise ChatSDK::SignatureVerificationError, "Missing authorization header" unless auth_header
+
+        token = auth_header.sub(/^Bearer\s+/i, "")
+        @jwt_verifier.verify!(token)
+        true
+      end
+
+      def parse_events(rack_request)
+        body = rack_request.body.read
+        rack_request.body.rewind
+
+        activity = JSON.parse(body)
+
+        # Cache the service URL for this conversation
+        if activity["serviceUrl"] && activity.dig("conversation", "id")
+          @service_urls[activity.dig("conversation", "id")] = activity["serviceUrl"]
+        end
+
+        ActivityParser.parse(activity, bot_app_id: @app_id)
+      rescue JSON::ParserError
+        []
+      end
+
+      # Outbound
+      def post_message(channel_id:, message:, thread_id: nil)
+        msg = ChatSDK::PostableMessage.from(message)
+        service_url = service_url_for(channel_id)
+
+        activity = build_activity(msg)
+        activity["replyToId"] = thread_id if thread_id
+
+        result = @client.send_activity(
+          service_url: service_url,
+          conversation_id: channel_id,
+          activity: activity
+        )
+
+        ChatSDK::Message.new(
+          id: result["id"],
+          text: msg.text || "",
+          author: ChatSDK::Author.new(id: @app_id, name: "bot", platform: :teams, bot: true),
+          thread_id: thread_id || result["id"],
+          channel_id: channel_id,
+          platform: :teams,
+          raw: result
+        )
+      end
+
+      def edit_message(channel_id:, message_id:, message:)
+        require_capability!(:edit_messages)
+        msg = ChatSDK::PostableMessage.from(message)
+        service_url = service_url_for(channel_id)
+
+        activity = build_activity(msg)
+        activity["id"] = message_id
+
+        @client.update_activity(
+          service_url: service_url,
+          conversation_id: channel_id,
+          activity_id: message_id,
+          activity: activity
+        )
+      end
+
+      def delete_message(channel_id:, message_id:)
+        require_capability!(:delete_messages)
+        service_url = service_url_for(channel_id)
+
+        @client.delete_activity(
+          service_url: service_url,
+          conversation_id: channel_id,
+          activity_id: message_id
+        )
+      end
+
+      def post_ephemeral(channel_id:, user_id:, message:, thread_id: nil)
+        super # raises NotSupportedError
+      end
+
+      def upload_file(channel_id:, io:, filename:, thread_id: nil, comment: nil)
+        require_capability!(:file_uploads)
+        # Teams file uploads are done via attachments in activities
+        service_url = service_url_for(channel_id)
+        content = Base64.strict_encode64(io.read)
+
+        activity = {
+          "type" => "message",
+          "text" => comment || "",
+          "attachments" => [{
+            "contentType" => "application/octet-stream",
+            "name" => filename,
+            "contentUrl" => "data:application/octet-stream;base64,#{content}"
+          }]
+        }
+        activity["replyToId"] = thread_id if thread_id
+
+        @client.send_activity(
+          service_url: service_url,
+          conversation_id: channel_id,
+          activity: activity
+        )
+      end
+
+      def add_reaction(channel_id:, message_id:, emoji:)
+        require_capability!(:reactions)
+        # Teams Bot Framework API does not support adding reactions programmatically
+        # The capability is declared because inbound reactions are parsed
+        raise ChatSDK::PlatformError.new(
+          "Teams Bot Framework API does not support adding reactions programmatically",
+          adapter_name: :teams
+        )
+      end
+
+      def remove_reaction(channel_id:, message_id:, emoji:)
+        require_capability!(:reactions)
+        raise ChatSDK::PlatformError.new(
+          "Teams Bot Framework API does not support removing reactions programmatically",
+          adapter_name: :teams
+        )
+      end
+
+      def open_dm(user_id)
+        require_capability!(:direct_messages)
+        # To open a DM, we need a service URL. Use the first cached one.
+        service_url = @service_urls.values.first
+        unless service_url
+          raise ChatSDK::PlatformError.new(
+            "No service URL available. A Teams activity must be received first.",
+            adapter_name: :teams
+          )
+        end
+
+        payload = {
+          "bot" => {"id" => @app_id},
+          "members" => [{"id" => user_id}],
+          "isGroup" => false
+        }
+
+        result = @client.create_conversation(service_url: service_url, payload: payload)
+        conversation_id = result["id"]
+        @service_urls[conversation_id] = service_url
+        conversation_id
+      end
+
+      def fetch_messages(channel_id:, thread_id: nil, cursor: nil, limit: 50)
+        require_capability!(:message_history)
+        # Teams Bot Framework doesn't provide a message history API
+        # Return empty to satisfy the interface
+        [[], nil]
+      end
+
+      def open_modal(trigger_id:, modal:)
+        super # raises NotSupportedError
+      end
+
+      def start_typing(channel_id:, thread_id: nil)
+        super # raises NotSupportedError
+      end
+
+      def mention(user_id)
+        "<at>#{user_id}</at>"
+      end
+
+      def render(postable_message)
+        msg = ChatSDK::PostableMessage.from(postable_message)
+        if msg.card?
+          @renderer.render(msg.card)
+        else
+          msg.text
+        end
+      end
+
+      # Store a service URL for a conversation (useful when sending proactive messages)
+      def register_service_url(conversation_id, service_url)
+        @service_urls[conversation_id] = service_url
+      end
+
+      private
+
+      def build_activity(postable_message)
+        activity = {"type" => "message"}
+
+        if postable_message.card?
+          card_json = @renderer.render(postable_message.card)
+          activity["attachments"] = [{
+            "contentType" => "application/vnd.microsoft.card.adaptive",
+            "content" => card_json
+          }]
+          activity["text"] = postable_message.text || postable_message.card.fallback_text
+        else
+          activity["text"] = postable_message.text
+        end
+
+        activity
+      end
+
+      def service_url_for(channel_id)
+        url = @service_urls[channel_id]
+        unless url
+          raise ChatSDK::PlatformError.new(
+            "No service URL for conversation #{channel_id}. Register it first or receive an activity.",
+            adapter_name: :teams
+          )
+        end
+        url
+      end
+    end
+  end
+end

data/lib/chat_sdk/teams/adaptive_card_renderer.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+module ChatSDK
+  module Teams
+    class AdaptiveCardRenderer
+      def render(node)
+        case node.type
+        when :card then render_card(node)
+        else wrap_card([render_node(node)].compact)
+        end
+      end
+
+      private
+
+      def render_card(node)
+        body = []
+        pending_separator = false
+
+        node.children.each do |child|
+          if child.type == :divider
+            pending_separator = true
+            next
+          end
+
+          element = render_node(child)
+          next unless element
+
+          if pending_separator
+            element["separator"] = true
+            pending_separator = false
+          end
+
+          if element.is_a?(Array)
+            body.concat(element)
+          else
+            body << element
+          end
+        end
+
+        wrap_card(body)
+      end
+
+      def wrap_card(body)
+        {
+          "type" => "AdaptiveCard",
+          "$schema" => "http://adaptivecards.io/schemas/adaptive-card.json",
+          "version" => "1.4",
+          "body" => body
+        }
+      end
+
+      def render_node(node)
+        case node.type
+        when :text then render_text(node)
+        when :divider then nil # handled in render_card
+        when :image then render_image(node)
+        when :fields then render_fields(node)
+        when :section then render_section(node)
+        when :actions then render_actions(node)
+        when :button then render_action_submit(node)
+        when :link_button then render_action_open_url(node)
+        when :select then render_select(node)
+        end
+      end
+
+      def render_text(node)
+        {
+          "type" => "TextBlock",
+          "text" => node.attributes[:content],
+          "wrap" => true
+        }
+      end
+
+      def render_image(node)
+        block = {
+          "type" => "Image",
+          "url" => node.attributes[:url]
+        }
+        block["altText"] = node.attributes[:alt] if node.attributes[:alt]
+        block
+      end
+
+      def render_fields(node)
+        {
+          "type" => "FactSet",
+          "facts" => node.children.map do |field|
+            {
+              "title" => field.attributes[:label],
+              "value" => field.attributes[:value]
+            }
+          end
+        }
+      end
+
+      def render_section(node)
+        elements = []
+        if node.attributes[:title]
+          elements << {
+            "type" => "TextBlock",
+            "text" => node.attributes[:title],
+            "weight" => "bolder",
+            "size" => "medium",
+            "wrap" => true
+          }
+        end
+        node.children.each do |child|
+          el = render_node(child)
+          next unless el
+          if el.is_a?(Array)
+            elements.concat(el)
+          else
+            elements << el
+          end
+        end
+        {
+          "type" => "Container",
+          "items" => elements
+        }
+      end
+
+      def render_actions(node)
+        actions = node.children.filter_map { |child| render_action_element(child) }
+        {
+          "type" => "ActionSet",
+          "actions" => actions
+        }
+      end
+
+      def render_action_element(node)
+        case node.type
+        when :button then render_action_submit(node)
+        when :link_button then render_action_open_url(node)
+        when :select then render_select(node)
+        end
+      end
+
+      def render_action_submit(node)
+        action = {
+          "type" => "Action.Submit",
+          "title" => node.attributes[:text],
+          "data" => {"action" => node.attributes[:id]}
+        }
+        action["data"]["value"] = node.attributes[:value] if node.attributes[:value]
+        if node.attributes[:style] == :primary
+          action["style"] = "positive"
+        elsif node.attributes[:style] == :danger
+          action["style"] = "destructive"
+        end
+        action
+      end
+
+      def render_action_open_url(node)
+        {
+          "type" => "Action.OpenUrl",
+          "title" => node.attributes[:text],
+          "url" => node.attributes[:url]
+        }
+      end
+
+      def render_select(node)
+        input = {
+          "type" => "Input.ChoiceSet",
+          "id" => node.attributes[:id],
+          "choices" => node.children.map do |opt|
+            {
+              "title" => opt.attributes[:text],
+              "value" => opt.attributes[:value]
+            }
+          end
+        }
+        input["placeholder"] = node.attributes[:placeholder] if node.attributes[:placeholder]
+        input
+      end
+    end
+  end
+end

data/lib/chat_sdk/teams/bot_framework_client.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module ChatSDK
+  module Teams
+    class BotFrameworkClient
+      TOKEN_URL = "https://login.microsoftonline.com/botframework.com/oauth2/v2.0/token"
+      SCOPE = "https://api.botframework.com/.default"
+
+      attr_reader :app_id, :app_password
+
+      def initialize(app_id:, app_password:)
+        @app_id = app_id
+        @app_password = app_password
+        @access_token = nil
+        @token_expires_at = nil
+      end
+
+      def send_activity(service_url:, conversation_id:, activity:)
+        url = "#{service_url.chomp("/")}/v3/conversations/#{conversation_id}/activities"
+        authorized_request(:post, url, activity)
+      end
+
+      def reply_to_activity(service_url:, conversation_id:, activity_id:, activity:)
+        url = "#{service_url.chomp("/")}/v3/conversations/#{conversation_id}/activities/#{activity_id}"
+        authorized_request(:put, url, activity)
+      end
+
+      def update_activity(service_url:, conversation_id:, activity_id:, activity:)
+        url = "#{service_url.chomp("/")}/v3/conversations/#{conversation_id}/activities/#{activity_id}"
+        authorized_request(:put, url, activity)
+      end
+
+      def delete_activity(service_url:, conversation_id:, activity_id:)
+        url = "#{service_url.chomp("/")}/v3/conversations/#{conversation_id}/activities/#{activity_id}"
+        authorized_request(:delete, url)
+      end
+
+      def create_conversation(service_url:, payload:)
+        url = "#{service_url.chomp("/")}/v3/conversations"
+        authorized_request(:post, url, payload)
+      end
+
+      def get_conversation_members(service_url:, conversation_id:)
+        url = "#{service_url.chomp("/")}/v3/conversations/#{conversation_id}/members"
+        authorized_request(:get, url)
+      end
+
+      def fetch_token
+        return @access_token if @access_token && @token_expires_at && Time.now < @token_expires_at
+
+        conn = Faraday.new do |f|
+          f.request :url_encoded
+          f.adapter :net_http
+        end
+
+        response = conn.post(TOKEN_URL, {
+          grant_type: "client_credentials",
+          client_id: @app_id,
+          client_secret: @app_password,
+          scope: SCOPE
+        })
+
+        unless response.success?
+          raise ChatSDK::PlatformError.new(
+            "Failed to acquire Bot Framework token: #{response.status}",
+            status: response.status,
+            body: response.body,
+            adapter_name: :teams
+          )
+        end
+
+        data = JSON.parse(response.body)
+        @access_token = data["access_token"]
+        @token_expires_at = Time.now + (data["expires_in"].to_i - 60)
+        @access_token
+      end
+
+      private
+
+      def authorized_request(method, url, body = nil)
+        token = fetch_token
+
+        conn = Faraday.new do |f|
+          f.request :json if body
+          f.response :json
+          f.adapter :net_http
+        end
+
+        response = conn.public_send(method, url) do |req|
+          req.headers["Authorization"] = "Bearer #{token}"
+          req.headers["Content-Type"] = "application/json" if body
+          req.body = JSON.generate(body) if body && !method.to_s.start_with?("get")
+        end
+
+        unless response.success?
+          raise ChatSDK::PlatformError.new(
+            "Bot Framework API error: #{response.status}",
+            status: response.status,
+            body: response.body,
+            adapter_name: :teams
+          )
+        end
+
+        response.body
+      end
+    end
+  end
+end

data/lib/chat_sdk/teams/jwt_verifier.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module ChatSDK
+  module Teams
+    class JwtVerifier
+      OPENID_CONFIG_URL = "https://login.botframework.com/v1/.well-known/openidconfiguration"
+      JWKS_CACHE_TTL = 3600 # 1 hour
+
+      def initialize(app_id:)
+        @app_id = app_id
+        @jwks_keys = nil
+        @jwks_fetched_at = nil
+      end
+
+      def verify!(token)
+        raise ChatSDK::SignatureVerificationError, "Missing authorization token" if token.nil? || token.empty?
+
+        jwks = fetch_jwks
+        header = JWT.decode(token, nil, false).last
+        kid = header["kid"]
+
+        key = jwks.find { |k| k[:kid] == kid }
+        raise ChatSDK::SignatureVerificationError, "Unknown signing key" unless key
+
+        decoded = JWT.decode(
+          token,
+          key[:key],
+          true,
+          algorithm: header["alg"] || "RS256",
+          aud: @app_id,
+          verify_aud: true
+        )
+        decoded.first
+      rescue JWT::DecodeError, JWT::VerificationError, JWT::ExpiredSignature, JWT::InvalidAudError => e
+        raise ChatSDK::SignatureVerificationError, "JWT verification failed: #{e.message}"
+      end
+
+      private
+
+      def fetch_jwks
+        if @jwks_keys && @jwks_fetched_at && (Time.now - @jwks_fetched_at) < JWKS_CACHE_TTL
+          return @jwks_keys
+        end
+
+        config_response = Faraday.get(OPENID_CONFIG_URL)
+        config = JSON.parse(config_response.body)
+        jwks_uri = config["jwks_uri"]
+
+        jwks_response = Faraday.get(jwks_uri)
+        jwks_data = JSON.parse(jwks_response.body)
+
+        @jwks_keys = jwks_data["keys"].map do |key_data|
+          next unless key_data["kty"] == "RSA"
+
+          rsa_key = build_rsa_key(key_data)
+          {kid: key_data["kid"], key: rsa_key}
+        end.compact
+
+        @jwks_fetched_at = Time.now
+        @jwks_keys
+      end
+
+      def build_rsa_key(key_data)
+        n = base64url_to_bn(key_data["n"])
+        e = base64url_to_bn(key_data["e"])
+
+        # Build RSA public key via DER encoding (compatible with OpenSSL 3.x)
+        rsa_public_key = OpenSSL::ASN1::Sequence.new([
+          OpenSSL::ASN1::Integer.new(n),
+          OpenSSL::ASN1::Integer.new(e)
+        ])
+
+        der = OpenSSL::ASN1::Sequence.new([
+          OpenSSL::ASN1::Sequence.new([
+            OpenSSL::ASN1::ObjectId.new("rsaEncryption"),
+            OpenSSL::ASN1::Null.new(nil)
+          ]),
+          OpenSSL::ASN1::BitString.new(rsa_public_key.to_der)
+        ]).to_der
+
+        OpenSSL::PKey::RSA.new(der)
+      end
+
+      def base64url_to_bn(str)
+        decoded = Base64.urlsafe_decode64(str)
+        OpenSSL::BN.new(decoded, 2)
+      end
+    end
+  end
+end

data/lib/chat_sdk/teams.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "chat_sdk"
+require "faraday"
+require "faraday/net_http"
+require "jwt"
+require "zeitwerk"
+
+module ChatSDK
+  module Teams
+    class << self
+      def loader
+        @loader ||= begin
+          loader = Zeitwerk::Loader.new
+          loader.tag = "chat_sdk-teams"
+          loader.inflector.inflect("chat_sdk" => "ChatSDK")
+          loader.push_dir("#{__dir__}/teams", namespace: ChatSDK::Teams)
+          loader.setup
+          loader
+        end
+      end
+    end
+  end
+end
+
+ChatSDK::Teams.loader

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification
+name: chat_sdk-teams
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Rootly
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: chat_sdk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: jwt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.7'
+description: Microsoft Teams bot adapter for the ChatSDK framework
+email:
+- eng@rootly.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/chat_sdk/teams.rb
+- lib/chat_sdk/teams/activity_parser.rb
+- lib/chat_sdk/teams/adapter.rb
+- lib/chat_sdk/teams/adaptive_card_renderer.rb
+- lib/chat_sdk/teams/bot_framework_client.rb
+- lib/chat_sdk/teams/jwt_verifier.rb
+homepage: https://github.com/rootlyhq/rootly-chat-sdk
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.16
+specification_version: 4
+summary: Microsoft Teams adapter for ChatSDK
+test_files: []