chat_sdk-teams 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5dd8b4de05c46835a9f07d65dd88446c9b76bc3caef20447fbf2e660d6244e32
-  data.tar.gz: ffd479d4c04b616d7f18559871f999f7b02d81ef627fd5a0da1eca3a2021d44e
+  metadata.gz: 7a6410c72972c0210380902fcf4a176c992c68d7c18154ff55f2a286fe1823a2
+  data.tar.gz: 59897106f6792d7ec3c73b76de36019fa1eb40126ec120bf28060fe35cc47cc2
 SHA512:
-  metadata.gz: 180473cb244ebb81bbbfc2c6027525dead9def447370eab1a22a4332b81cbe116a7391bc64dfb9ece492c40106d2984a705c6529fb0506755650370630cd6f34
-  data.tar.gz: 225fa926d125f21ff5cb9c970015aa9da7e7d5415caf0fbceac7d9cd73ee11223ebe74b18a3e75fb5078fd1dd3efdab50eceb293286f7d6a5ef2e35cd00404fe
+  metadata.gz: 485f8fea6b1f2702b71a7b1a78cbef630255c0a88d92d5b8e04a723bc30fd7629746eb9a84fc6e99871baec9dc488aeb7ee2bfebfaacf60a95e298f48a3b4571
+  data.tar.gz: f25e032254fee24a840cd7c14afd317ea45c279e404f2bfb6cf5a494d20803f980f2452d7e6a99e6f3d7b485a435c6cf4316682b3cdc3737fcd45eb5072ef8ab

data/lib/chat_sdk/teams/activity_parser.rb

@@ -9,11 +9,17 @@ module ChatSDK
 
           case activity["type"]
           when "message"
-            parse_message(activity, bot_app_id)
+            if action_submission?(activity)
+              parse_invoke(activity, bot_app_id)
+            else
+              parse_message(activity, bot_app_id)
+            end
           when "messageReaction"
             parse_message_reaction(activity)
           when "invoke"
-            parse_invoke(activity)
+            parse_invoke(activity, bot_app_id)
+          when "installationUpdate"
+            parse_installation(activity, bot_app_id)
           else
             []
           end
@@ -22,9 +28,9 @@ module ChatSDK
         private
 
         def parse_message(activity, bot_app_id)
-          return [] if activity.dig("from", "id") == bot_app_id
+          return [] if self_message?(activity, bot_app_id)
 
-          author = build_author(activity)
+          author = build_author(activity, bot_app_id)
           conversation_id = activity.dig("conversation", "id")
           thread_id = activity.dig("conversation", "id")
 
@@ -103,19 +109,37 @@ module ChatSDK
           events
         end
 
-        def parse_invoke(activity)
+        def parse_invoke(activity, bot_app_id)
           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"]
+          user = build_author(activity, bot_app_id)
+
+          value_data = activity["value"]
+          nested_data = value_data["data"] if value_data.is_a?(Hash)
+          action = value_data["action"] if value_data.is_a?(Hash)
+          action_data = action.is_a?(Hash) ? action["data"] : nil
+          data = if nested_data.is_a?(Hash)
+            nested_data
+          elsif action_data.is_a?(Hash)
+            action_data
+          else
+            value_data
+          end
+          data = {} unless data.is_a?(Hash)
+          action_id = if action_data.is_a?(Hash)
+            action_data["actionId"] || action_data["action"]
+          end
+          action_id ||= action["verb"] if action.is_a?(Hash)
+          action_id ||= data["actionId"] || data["action"] ||
+            (action unless action.is_a?(Hash)) || activity["name"] || "invoke"
+          value = data["value"] || (nested_data unless nested_data.is_a?(Hash)) || data
           value = value.is_a?(Hash) ? JSON.generate(value) : value.to_s
 
           [ChatSDK::Events::Action.new(
             action_id: action_id,
             value: value,
+            values: action_values(data),
             user: user,
             thread_id: conversation_id,
             channel_id: conversation_id,
@@ -125,17 +149,80 @@ module ChatSDK
           )]
         end
 
-        def build_author(activity)
+        def action_submission?(activity)
+          value = activity["value"]
+          value.is_a?(Hash) && (value.key?("data") || value.key?("action") || value.key?("actionId"))
+        end
+
+        def parse_installation(activity, bot_app_id)
+          return [] unless app_id?(activity.dig("recipient", "id"), bot_app_id)
+
+          action = activity["action"]
+          event_class = case action
+          when "add", "add-upgrade" then ChatSDK::Events::Installed
+          when "remove", "remove-upgrade" then ChatSDK::Events::Uninstalled
+          else return []
+          end
+
+          conversation_id = activity.dig("conversation", "id")
+          return [] unless conversation_id
+
+          team_id = activity.dig("channelData", "team", "id")
+          tenant_id = activity.dig("conversation", "tenantId") ||
+            activity.dig("channelData", "tenant", "id")
+          user_id = activity.dig("from", "aadObjectId") || activity.dig("from", "id")
+          installation_id = if team_id
+            team_id
+          elsif tenant_id && user_id
+            "#{tenant_id}:#{user_id}"
+          else
+            tenant_id || conversation_id
+          end
+          [event_class.new(
+            installation_id: installation_id,
+            team_id: team_id,
+            tenant_id: tenant_id,
+            conversation_id: conversation_id,
+            action: action,
+            user: build_author(activity, bot_app_id),
+            platform: :teams,
+            adapter_name: :teams,
+            raw: activity
+          )]
+        end
+
+        def build_author(activity, bot_app_id)
           from = activity["from"] || {}
+          from_id = from["id"] || "unknown"
           ChatSDK::Author.new(
-            id: from["id"] || "unknown",
-            name: from["name"] || from["id"] || "unknown",
+            id: from_id,
+            name: from["name"] || from_id,
             platform: :teams,
-            bot: from["role"] == "bot",
+            bot: from["role"].to_s.downcase == "bot" || from_id.start_with?("28:"),
+            me: self_message?(activity, bot_app_id),
             locale: activity["locale"]
           )
         end
 
+        def self_message?(activity, bot_app_id)
+          from_id = activity.dig("from", "id")
+          return true if app_id?(from_id, bot_app_id)
+
+          recipient_id = activity.dig("recipient", "id")
+          from_id && recipient_id && from_id == recipient_id
+        end
+
+        def app_id?(id, bot_app_id)
+          return false unless id && bot_app_id
+
+          id == bot_app_id || id == "28:#{bot_app_id}"
+        end
+
+        def action_values(data)
+          values = data.except("action", "actionId", "value", "msteams")
+          values.empty? ? nil : values
+        end
+
         def bot_mentioned?(activity, bot_app_id)
           return false unless bot_app_id
 

data/lib/chat_sdk/teams/adapter.rb

@@ -1,15 +1,21 @@
 # frozen_string_literal: true
 
+require "uri"
+
 module ChatSDK
   module Teams
     class Adapter < ChatSDK::Adapter::Base
+      DEFAULT_SERVICE_URL = "https://smba.trafficmanager.net/teams/"
+      VERIFIED_JWT_CLAIMS_ENV_KEY = "chat_sdk.teams.verified_jwt_claims"
+
       capabilities :edit_messages, :delete_messages, :threads, :direct_messages,
         :file_uploads, :streaming_edit, :typing_indicator, :message_history
 
       attr_reader :client
 
       def initialize(app_id: nil, app_password: nil, tenant_id: nil,
-        graph_client_id: nil, graph_client_secret: nil, graph_tenant_id: nil)
+        graph_client_id: nil, graph_client_secret: nil, graph_tenant_id: nil,
+        service_url: 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"]
@@ -21,6 +27,7 @@ module ChatSDK
         @graph_client_secret = graph_client_secret || ENV["TEAMS_GRAPH_CLIENT_SECRET"]
         @graph_tenant_id = graph_tenant_id || ENV["TEAMS_GRAPH_TENANT_ID"]
         @graph_client = GraphClient.new(@graph_client_id, @graph_client_secret, @graph_tenant_id) if @graph_client_id
+        @default_service_url = service_url || ENV["TEAMS_SERVICE_URL"] || DEFAULT_SERVICE_URL
 
         @client = BotFrameworkClient.new(app_id: @app_id, app_password: @app_password)
         @jwt_verifier = JwtVerifier.new(app_id: @app_id)
@@ -28,6 +35,10 @@ module ChatSDK
         @service_urls = {}
       end
 
+      def set_state(state)
+        @state = state
+      end
+
       def name
         :teams
       end
@@ -38,16 +49,17 @@ module ChatSDK
         raise ChatSDK::SignatureVerificationError, "Missing authorization header" unless auth_header
 
         token = auth_header.sub(/^Bearer\s+/i, "")
-        @jwt_verifier.verify!(token)
+        rack_request.env[VERIFIED_JWT_CLAIMS_ENV_KEY] = @jwt_verifier.verify!(token)
         true
       end
 
       def parse_events(rack_request)
         activity = read_json_body(rack_request)
 
-        # Cache the service URL for this conversation
-        if activity["serviceUrl"] && activity.dig("conversation", "id")
-          @service_urls[activity.dig("conversation", "id")] = activity["serviceUrl"]
+        conversation_id = activity.dig("conversation", "id")
+        claims = rack_request.env[VERIFIED_JWT_CLAIMS_ENV_KEY]
+        if conversation_id && trusted_service_url?(activity["serviceUrl"], claims)
+          register_service_url(conversation_id, activity["serviceUrl"])
         end
 
         ActivityParser.parse(activity, bot_app_id: @app_id)
@@ -61,7 +73,7 @@ module ChatSDK
         service_url = service_url_for(channel_id)
 
         activity = build_activity(msg)
-        activity["replyToId"] = thread_id if thread_id
+        activity["replyToId"] = activity_reply_id(channel_id, thread_id) if thread_id
 
         result = @client.send_activity(
           service_url: service_url,
@@ -73,14 +85,14 @@ module ChatSDK
           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"],
+          thread_id: thread_id || channel_thread_id(channel_id, result["id"]),
           channel_id: channel_id,
           platform: :teams,
           raw: result
         )
       end
 
-      def edit_message(channel_id:, message_id:, message:)
+      def edit_message(channel_id:, message_id:, message:, **_options)
         require_capability!(:edit_messages)
         msg = ChatSDK::PostableMessage.from(message)
         service_url = service_url_for(channel_id)
@@ -96,7 +108,7 @@ module ChatSDK
         )
       end
 
-      def delete_message(channel_id:, message_id:)
+      def delete_message(channel_id:, message_id:, **_options)
         require_capability!(:delete_messages)
         service_url = service_url_for(channel_id)
 
@@ -126,7 +138,7 @@ module ChatSDK
             "contentUrl" => "data:application/octet-stream;base64,#{content}"
           }]
         }
-        activity["replyToId"] = thread_id if thread_id
+        activity["replyToId"] = activity_reply_id(channel_id, thread_id) if thread_id
 
         @client.send_activity(
           service_url: service_url,
@@ -137,14 +149,7 @@ module ChatSDK
 
       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
+        service_url = @service_urls.values.first || @default_service_url
 
         payload = {
           "bot" => {"id" => @app_id},
@@ -154,7 +159,7 @@ module ChatSDK
 
         result = @client.create_conversation(service_url: service_url, payload: payload)
         conversation_id = result["id"]
-        @service_urls[conversation_id] = service_url
+        register_service_url(conversation_id, service_url)
         conversation_id
       end
 
@@ -162,7 +167,7 @@ module ChatSDK
         super
       end
 
-      def start_typing(channel_id:, thread_id: nil)
+      def start_typing(channel_id:, thread_id: nil, message_id: nil)
         service_url = service_url_for(channel_id)
         @client.send_typing(
           service_url: service_url,
@@ -191,7 +196,7 @@ module ChatSDK
             "(TEAMS_GRAPH_CLIENT_ID, TEAMS_GRAPH_CLIENT_SECRET, TEAMS_GRAPH_TENANT_ID)"
         end
 
-        result = @graph_client.fetch_messages(chat_id: channel_id, limit: limit)
+        result = @graph_client.fetch_messages(chat_id: channel_id, limit: limit, cursor: cursor)
         messages = (result["value"] || []).map { |m| parse_graph_message(m, channel_id) }
         next_link = result["@odata.nextLink"]
         [messages, next_link]
@@ -200,6 +205,18 @@ module ChatSDK
       # 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
+        @state&.set(service_url_key(conversation_id), service_url)
+      end
+
+      def webhook_response(events)
+        return unless events.any? { |event| event.raw.is_a?(Hash) && event.raw["type"] == "invoke" }
+
+        body = {
+          "statusCode" => 200,
+          "type" => "application/vnd.microsoft.activity.message",
+          "value" => "OK"
+        }
+        [200, {"content-type" => "application/json"}, [JSON.generate(body)]]
       end
 
       private
@@ -218,11 +235,25 @@ module ChatSDK
           activity["text"] = postable_message.text
         end
 
+        if postable_message.ai_generated
+          activity["entities"] = [{
+            "type" => "https://schema.org/Message",
+            "@type" => "Message",
+            "@context" => "https://schema.org",
+            "additionalType" => ["AIGeneratedContent"]
+          }]
+        end
+
         activity
       end
 
       def service_url_for(channel_id)
         url = @service_urls[channel_id]
+        if !url && @state
+          url = @state.get(service_url_key(channel_id))
+          @service_urls[channel_id] = url if url
+        end
+        url ||= @default_service_url
         unless url
           raise ChatSDK::PlatformError.new(
             "No service URL for conversation #{channel_id}. Register it first or receive an activity.",
@@ -232,10 +263,61 @@ module ChatSDK
         url
       end
 
+      def service_url_key(conversation_id)
+        "chat_sdk:teams:service_url:#{conversation_id}"
+      end
+
+      def trusted_service_url?(service_url, claims)
+        return false unless service_url.is_a?(String)
+
+        uri = URI.parse(service_url)
+        return false unless uri.scheme&.casecmp?("https") && uri.host
+
+        service_url_claim = claims.is_a?(Hash) ? claims["serviceurl"] : nil
+        service_url_claim.nil? ||
+          (service_url_claim.is_a?(String) &&
+            normalize_service_url(service_url) == normalize_service_url(service_url_claim))
+      rescue URI::InvalidURIError
+        false
+      end
+
+      def normalize_service_url(service_url)
+        uri = URI.parse(service_url)
+        return unless uri.scheme && uri.host
+
+        uri.scheme = uri.scheme.downcase
+        uri.host = uri.host.downcase
+        uri.path = uri.path.delete_suffix("/")
+        uri.to_s
+      rescue URI::InvalidURIError
+        nil
+      end
+
+      def channel_thread_id(channel_id, activity_id)
+        return activity_id unless channel_id.to_s.include?("@thread.tacv2") && activity_id
+
+        "#{channel_id};messageid=#{activity_id}"
+      end
+
+      def activity_reply_id(channel_id, thread_id)
+        prefix = "#{channel_id};messageid="
+        thread_id.start_with?(prefix) ? thread_id.delete_prefix(prefix) : thread_id
+      end
+
       def parse_graph_message(data, channel_id)
         from = data["from"] || {}
         user = from["user"] || from["application"] || {}
         is_bot = !from["application"].nil?
+        attachments = Array(data["attachments"]).filter_map do |attachment|
+          next unless attachment["contentType"] == "reference" && attachment["contentUrl"]
+
+          begin
+            resolved = @graph_client.resolve_reference_attachment(content_url: attachment["contentUrl"])
+            resolved.merge("filename" => resolved["filename"] || attachment["name"])
+          rescue ChatSDK::PlatformError, ArgumentError, Faraday::Error
+            nil
+          end
+        end
 
         ChatSDK::Message.new(
           id: data["id"],
@@ -244,11 +326,13 @@ module ChatSDK
             id: user["id"] || "unknown",
             name: user["displayName"] || "unknown",
             platform: :teams,
-            bot: is_bot
+            bot: is_bot,
+            me: is_bot && user["id"] == @app_id
           ),
           thread_id: data["replyToId"] || data["id"],
           channel_id: channel_id,
           platform: :teams,
+          attachments: attachments,
           timestamp: data["createdDateTime"],
           raw: data
         )

data/lib/chat_sdk/teams/adaptive_card_renderer.rb

@@ -62,6 +62,7 @@ module ChatSDK
         when :button then render_action_submit(node)
         when :link_button then render_action_open_url(node)
         when :select then render_select(node)
+        when :text_input then render_text_input(node)
         when :table then render_table(node)
         when :chart then render_chart(node)
         end
@@ -142,7 +143,7 @@ module ChatSDK
         action = {
           "type" => "Action.Submit",
           "title" => node.attributes[:text],
-          "data" => {"action" => node.attributes[:id]}
+          "data" => {"actionId" => node.attributes[:id]}
         }
         action["data"]["value"] = node.attributes[:value] if node.attributes[:value]
         action["tooltip"] = node.attributes[:tooltip] if node.attributes[:tooltip]
@@ -180,23 +181,65 @@ module ChatSDK
         input
       end
 
+      def render_text_input(node)
+        input = {
+          "type" => "Input.Text",
+          "id" => node.attributes[:id],
+          "label" => node.attributes[:label],
+          "isMultiline" => node.attributes[:multiline],
+          "isRequired" => !node.attributes[:optional]
+        }
+        input["placeholder"] = node.attributes[:placeholder] if node.attributes[:placeholder]
+        input["value"] = node.attributes[:value] unless node.attributes[:value].nil?
+        input
+      end
+
       def render_table(node)
-        rows = [Array(node.attributes[:headers]), *Array(node.attributes[:rows])]
+        headers = Array(node.attributes[:headers])
+        data_rows = Array(node.attributes[:rows])
+        column_count = data_rows.reduce(headers.length) { |count, row| [count, Array(row).length].max }
+        return if column_count.zero?
+
+        alignment = {left: "Left", center: "Center", right: "Right"}
+        vertical_alignment = {top: "Top", center: "Center", bottom: "Bottom"}
+        widths = Array(node.attributes[:widths])
+        aligns = Array(node.attributes[:align])
+        rows = data_rows.map { |row| Array(row) }
+        rows.unshift(headers) unless headers.empty?
+
         {
-          "type" => "Container",
-          "items" => rows.each_with_index.map do |row, index|
+          "type" => "Table",
+          "firstRowAsHeaders" => !headers.empty?,
+          "showGridLines" => node.attributes.fetch(:grid_lines, true),
+          "columns" => Array.new(column_count) do |index|
+            width = widths[index]
+            column_width = width
+            column_width = 1 unless column_width.is_a?(Integer) && column_width.positive?
+            column = {"width" => column_width}
+            column_alignment = alignment[aligns[index]&.to_sym]
+            column["horizontalCellContentAlignment"] = column_alignment if column_alignment
+            column
+          end,
+          "rows" => rows.each_with_index.map do |row, index|
             {
-              "type" => "ColumnSet",
-              "columns" => Array(row).map do |cell|
+              "type" => "TableRow",
+              "cells" => Array.new(column_count) do |cell_index|
                 {
-                  "type" => "Column",
-                  "width" => "stretch",
-                  "items" => [{"type" => "TextBlock", "text" => cell.to_s, "weight" => ("bolder" if index.zero?), "wrap" => true}.compact]
+                  "type" => "TableCell",
+                  "items" => [{
+                    "type" => "TextBlock",
+                    "text" => Array(row)[cell_index].to_s,
+                    "weight" => ("Bolder" if index.zero? && !headers.empty?),
+                    "wrap" => true
+                  }.compact]
                 }
               end
             }
-          end
+          end,
+          "gridStyle" => node.attributes[:grid_style],
+          "verticalCellContentAlignment" => vertical_alignment[node.attributes[:vertical_align]&.to_sym]
         }
+          .compact
       end
 
       def render_chart(node)

data/lib/chat_sdk/teams/graph_client.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require "base64"
+require "uri"
+
 module ChatSDK
   module Teams
     class GraphClient
@@ -15,9 +18,11 @@ module ChatSDK
         @token_expires_at = nil
       end
 
-      def fetch_messages(chat_id:, limit: 50)
+      def fetch_messages(chat_id:, limit: 50, cursor: nil)
+        messages_url = chat_messages_url(chat_id)
+        url = cursor || "#{messages_url}?$top=#{limit}&$orderby=createdDateTime desc"
+        validate_graph_url!(url, chat_id) if cursor
         token = fetch_token
-        url = "#{GRAPH_BASE_URL}/chats/#{chat_id}/messages?$top=#{limit}&$orderby=createdDateTime desc"
 
         response = api_connection.get(url) do |req|
           req.headers["Authorization"] = "Bearer #{token}"
@@ -35,6 +40,27 @@ module ChatSDK
         response.body
       end
 
+      def resolve_reference_attachment(content_url:)
+        item = fetch_reference_item(content_url)
+        {
+          "url" => item["@microsoft.graph.downloadUrl"],
+          "mime_type" => item.dig("file", "mimeType") || "application/octet-stream",
+          "filename" => item["name"]
+        }
+      end
+
+      def resolve_reference_url(content_url:)
+        resolve_reference_attachment(content_url: content_url).fetch("url")
+      end
+
+      def download_reference_attachment(content_url:)
+        download_url = resolve_reference_url(content_url: content_url)
+        uri = URI.parse(download_url)
+        raise ArgumentError, "Teams download URL must use HTTPS" unless uri.is_a?(URI::HTTPS)
+
+        Faraday.get(download_url)
+      end
+
       def fetch_token
         return @access_token if @access_token && @token_expires_at && Time.now < @token_expires_at
 
@@ -78,6 +104,52 @@ module ChatSDK
           f.adapter :net_http
         end
       end
+
+      def fetch_reference_item(content_url)
+        uri = URI.parse(content_url)
+        raise ArgumentError, "Teams attachment URL must use HTTPS" unless uri.is_a?(URI::HTTPS)
+
+        token = fetch_token
+        share_id = "u!#{Base64.urlsafe_encode64(content_url, padding: false)}"
+        response = api_connection.get("#{GRAPH_BASE_URL}/shares/#{share_id}/driveItem") do |req|
+          req.headers["Authorization"] = "Bearer #{token}"
+        end
+        unless response.success?
+          raise ChatSDK::PlatformError.new(
+            "Graph API error: #{response.status}",
+            status: response.status,
+            body: response.body,
+            adapter_name: :teams
+          )
+        end
+
+        item = response.body
+        unless item["@microsoft.graph.downloadUrl"]
+          raise ChatSDK::PlatformError.new("Graph API did not return an attachment download URL", adapter_name: :teams)
+        end
+
+        item
+      rescue URI::InvalidURIError
+        raise ArgumentError, "Invalid Teams attachment URL"
+      end
+
+      def chat_messages_url(chat_id)
+        "#{GRAPH_BASE_URL}/chats/#{URI::DEFAULT_PARSER.escape(chat_id.to_s, /[^A-Za-z0-9._~-]/)}/messages"
+      end
+
+      def validate_graph_url!(url, chat_id)
+        uri = URI.parse(url)
+        expected_path = URI::DEFAULT_PARSER.unescape(URI.parse(chat_messages_url(chat_id)).path)
+        actual_path = URI::DEFAULT_PARSER.unescape(uri.path)
+        valid = uri.is_a?(URI::HTTPS) && uri.host == "graph.microsoft.com" &&
+          uri.port == 443 && !uri.userinfo && !uri.fragment && actual_path == expected_path
+        unless valid
+          raise ArgumentError,
+            "Graph pagination cursor must use https://graph.microsoft.com and the requested chat path"
+        end
+      rescue URI::InvalidURIError
+        raise ArgumentError, "Invalid Graph pagination cursor"
+      end
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: chat_sdk-teams
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Quentin Rousseau
@@ -15,14 +15,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: '1.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: '1.2'
 - !ruby/object:Gem::Dependency
   name: faraday
   requirement: !ruby/object:Gem::Requirement