chat_sdk-teams 1.1.0 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5dd8b4de05c46835a9f07d65dd88446c9b76bc3caef20447fbf2e660d6244e32
-  data.tar.gz: ffd479d4c04b616d7f18559871f999f7b02d81ef627fd5a0da1eca3a2021d44e
+  metadata.gz: ebf993ca61c1fe27ad125af30af36361e87922b00ab33b5e80ab7f2cfc280eb3
+  data.tar.gz: 84470e0eaf8edc9eaeafd70d5e541ed0553c1ede14a1ee627f735d9f31aa8081
 SHA512:
-  metadata.gz: 180473cb244ebb81bbbfc2c6027525dead9def447370eab1a22a4332b81cbe116a7391bc64dfb9ece492c40106d2984a705c6529fb0506755650370630cd6f34
-  data.tar.gz: 225fa926d125f21ff5cb9c970015aa9da7e7d5415caf0fbceac7d9cd73ee11223ebe74b18a3e75fb5078fd1dd3efdab50eceb293286f7d6a5ef2e35cd00404fe
+  metadata.gz: 5b186d93dd6606ab6f8579c6ae1232ab217497e542e976a1e19de5cf08cdc84ffeeb0f8730905e66a30cfb9555a1b9ae01554f933dc29bfe3921b2db15d93175
+  data.tar.gz: 140ab32b11655a4732c06d15d0911600d6730d92f8f49963340b7e7a056b9e3050e893cd67e923bd32dccf4ab7b06e7d1797538c267322fea093c379e2a55702

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,41 @@ 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)
+          user = build_author(activity, bot_app_id)
 
-          action_id = activity.dig("value", "action") || activity["name"] || "invoke"
-          value = activity.dig("value", "data") || activity["value"]
+          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"
+          if action_id == AUTO_SUBMIT_ACTION_ID
+            return auto_submit_actions(data, activity, conversation_id, user)
+          end
+
+          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 +153,115 @@ 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 auto_submit_actions(data, activity, conversation_id, user)
+          values = auto_submit_values(data)
+          values = nil if values.empty?
+
+          data.each_with_object([]) do |(action_id, input_value), events|
+            next if %w[actionId msteams].include?(action_id)
+
+            events << ChatSDK::Events::Action.new(
+              action_id: action_id,
+              value: submit_value_to_string(input_value),
+              values: values,
+              user: user,
+              thread_id: conversation_id,
+              channel_id: conversation_id,
+              platform: :teams,
+              adapter_name: :teams,
+              raw: activity
+            )
+          end
+        end
+
+        def auto_submit_values(data)
+          data.each_with_object({}) do |(key, value), inputs|
+            next if %w[actionId msteams].include?(key)
+
+            input_value = submit_value_to_string(value)
+            inputs[key] = input_value unless input_value.nil?
+          end
+        end
+
+        def submit_value_to_string(value)
+          return value if value.is_a?(String)
+          value.to_s if value.is_a?(Numeric)
+        end
+
         def bot_mentioned?(activity, bot_app_id)
           return false unless bot_app_id
 

data/lib/chat_sdk/teams/adapter.rb

@@ -1,15 +1,22 @@
 # frozen_string_literal: true
 
+require "uri"
+
 module ChatSDK
   module Teams
     class Adapter < ChatSDK::Adapter::Base
+      DEFAULT_SERVICE_URL = "https://smba.trafficmanager.net/teams/"
+      USER_SERVICE_URL_TTL = 30 * 24 * 60 * 60
+      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 +28,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 +36,10 @@ module ChatSDK
         @service_urls = {}
       end
 
+      def set_state(state)
+        @state = state
+      end
+
       def name
         :teams
       end
@@ -38,16 +50,19 @@ 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 trusted_service_url?(activity["serviceUrl"], claims)
+          register_service_url(conversation_id, activity["serviceUrl"]) if conversation_id
+          user_id = activity.dig("from", "id")
+          @state&.set(user_service_url_key(user_id), activity["serviceUrl"], ttl: USER_SERVICE_URL_TTL) if user_id
         end
 
         ActivityParser.parse(activity, bot_app_id: @app_id)
@@ -61,7 +76,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 +88,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 +111,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 +141,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 +152,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 = @state&.get(user_service_url_key(user_id)) || @service_urls.values.first || @default_service_url
 
         payload = {
           "bot" => {"id" => @app_id},
@@ -154,7 +162,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 +170,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 +199,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,10 +208,31 @@ 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, rack_request = nil)
+        invoke_activity = rack_request&.respond_to?(:body) && invoke_activity?(rack_request)
+        invoke_event = events.any? { |event| event.raw.is_a?(Hash) && event.raw["type"] == "invoke" }
+        return unless invoke_activity || invoke_event
+
+        body = {
+          "statusCode" => 200,
+          "type" => "application/vnd.microsoft.activity.message",
+          "value" => "OK"
+        }
+        [200, {"content-type" => "application/json"}, [JSON.generate(body)]]
       end
 
       private
 
+      def invoke_activity?(rack_request)
+        activity = read_json_body(rack_request)
+        activity.is_a?(Hash) && activity["type"] == "invoke"
+      rescue JSON::ParserError
+        false
+      end
+
       def build_activity(postable_message)
         activity = {"type" => "message"}
 
@@ -218,11 +247,20 @@ 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]
+        url = @service_urls[channel_id] || @state&.get(service_url_key(channel_id)) || @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 +270,65 @@ module ChatSDK
         url
       end
 
+      def service_url_key(conversation_id)
+        "chat_sdk:teams:service_url:#{conversation_id}"
+      end
+
+      def user_service_url_key(user_id)
+        "chat_sdk:teams:user_service_url:#{user_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 +337,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

@@ -6,7 +6,10 @@ module ChatSDK
       def render(node)
         case node.type
         when :card then render_card(node)
-        else wrap_card([render_node(node)].compact)
+        else
+          rendered = render_node(node)
+          elements = rendered.is_a?(Array) ? rendered.flatten.compact : [rendered].compact
+          wrap_card(elements)
         end
       end
 
@@ -15,6 +18,13 @@ module ChatSDK
       def render_card(node)
         body = []
         pending_separator = false
+        if node.attributes[:image_url] && !node.attributes[:image_url].empty?
+          body << {
+            "type" => "Image",
+            "url" => node.attributes[:image_url],
+            "size" => "Stretch"
+          }
+        end
 
         node.children.each do |child|
           if child.type == :divider
@@ -25,16 +35,15 @@ module ChatSDK
           element = render_node(child)
           next unless element
 
+          elements = element.is_a?(Array) ? element.compact : [element]
+          next if elements.empty?
+
           if pending_separator
-            element["separator"] = true
+            elements.first["separator"] = true
             pending_separator = false
           end
 
-          if element.is_a?(Array)
-            body.concat(element)
-          else
-            body << element
-          end
+          body.concat(elements)
         end
 
         wrap_card(body, width: node.attributes[:width])
@@ -54,6 +63,7 @@ module ChatSDK
       def render_node(node)
         case node.type
         when :text then render_text(node)
+        when :link then render_link(node)
         when :divider then nil # handled in render_card
         when :image then render_image(node)
         when :fields then render_fields(node)
@@ -62,17 +72,30 @@ 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 :radio_select then render_radio_select(node)
+        when :text_input then render_text_input(node)
         when :table then render_table(node)
         when :chart then render_chart(node)
         end
       end
 
       def render_text(node)
-        {
+        text = {
           "type" => "TextBlock",
           "text" => node.attributes[:content],
           "wrap" => true
         }
+        text["weight"] = "Bolder" if node.attributes[:style] == :bold
+        text["isSubtle"] = true if node.attributes[:style] == :muted
+        text
+      end
+
+      def render_link(node)
+        {
+          "type" => "TextBlock",
+          "text" => "[#{node.attributes[:label]}](#{node.attributes[:url]})",
+          "wrap" => true
+        }
       end
 
       def render_image(node)
@@ -123,26 +146,44 @@ module ChatSDK
       end
 
       def render_actions(node)
-        actions = node.children.filter_map { |child| render_action_element(child) }
-        {
-          "type" => "ActionSet",
-          "actions" => actions
-        }
-      end
+        elements = []
+        actions = []
+        has_inputs = false
+        has_buttons = false
 
-      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)
+        node.children.each do |child|
+          case child.type
+          when :button
+            has_buttons = true
+            actions << render_action_submit(child)
+          when :link_button
+            actions << render_action_open_url(child)
+          when :select
+            has_inputs = true
+            elements << render_select(child)
+          when :radio_select
+            has_inputs = true
+            elements << render_radio_select(child)
+          end
+        end
+
+        if has_inputs && !has_buttons
+          actions << {
+            "type" => "Action.Submit",
+            "title" => "Submit",
+            "data" => {"actionId" => AUTO_SUBMIT_ACTION_ID}
+          }
         end
+
+        elements << {"type" => "ActionSet", "actions" => actions} unless actions.empty?
+        elements
       end
 
       def render_action_submit(node)
         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]
@@ -162,6 +203,11 @@ module ChatSDK
         }
         action["id"] = node.attributes[:id] if node.attributes[:id]
         action["tooltip"] = node.attributes[:tooltip] if node.attributes[:tooltip]
+        if node.attributes[:style] == :primary
+          action["style"] = "positive"
+        elsif node.attributes[:style] == :danger
+          action["style"] = "destructive"
+        end
         action
       end
 
@@ -177,26 +223,93 @@ module ChatSDK
           end
         }
         input["placeholder"] = node.attributes[:placeholder] if node.attributes[:placeholder]
+        if [node.attributes[:label], node.attributes[:initial_option], node.attributes[:optional]].any? { |value| !value.nil? }
+          input["label"] = node.attributes[:label] if node.attributes[:label]
+          input["style"] = "compact"
+          input["isRequired"] = !node.attributes[:optional]
+        end
+        input["value"] = node.attributes[:initial_option] unless node.attributes[:initial_option].nil?
+        input
+      end
+
+      def render_radio_select(node)
+        input = {
+          "type" => "Input.ChoiceSet",
+          "id" => node.attributes[:id],
+          "label" => node.attributes[:label],
+          "style" => "expanded",
+          "isRequired" => !node.attributes[:optional],
+          "choices" => node.children.map do |option|
+            {
+              "title" => option.attributes[:text],
+              "value" => option.attributes[:value]
+            }
+          end
+        }
+        input["value"] = node.attributes[:initial_option] unless node.attributes[:initial_option].nil?
+        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["maxLength"] = node.attributes[:max_length] unless node.attributes[:max_length].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

data/lib/chat_sdk/teams.rb

@@ -8,6 +8,8 @@ require "zeitwerk"
 
 module ChatSDK
   module Teams
+    AUTO_SUBMIT_ACTION_ID = "__auto_submit"
+
     class << self
       def loader
         @loader ||= begin

metadata

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