flow_chat 0.8.2 → 0.10.0

data/lib/flow_chat/whatsapp/middleware/choice_mapper.rb

@@ -0,0 +1,234 @@
+module FlowChat
+  module Whatsapp
+    module Middleware
+      # Maps what WhatsApp sends back to the choice key the flow branches on.
+      #
+      # The value on the wire is the title the user was shown, so a tap and a
+      # user typing what they read arrive as the same string and resolve
+      # through the same map.
+      #
+      # Flow:
+      # 1. Flow returns choices with original keys ({"create" => "Create Account"})
+      # 2. This middleware asks FlowChat::ChoiceTitles for each displayed title
+      # 3. It re-keys the choices by title and stores title => original key
+      # 4. Renderer receives the re-keyed choices and renders them
+      # 5. User taps a button, or types the title on it
+      # 6. This middleware resolves either back to the original key
+      #
+      # @example
+      #   # Flow provides: {"create" => "Create Account"}
+      #   # Titles built:  "Create Account"
+      #   # Transformed:   {"Create Account" => "Create Account"}
+      #   # Mapping:       {"Create Account" => "create"}
+      #
+      #   # With duplicates: {"yes" => "Accept", "no" => "Accept"}
+      #   # Titles built:  "1. Accept", "2. Accept"
+      #   # Mapping:       {"1. Accept" => "yes", "2. Accept" => "no"}
+      #
+      # A title is truncated to the rung's cap (see
+      # FlowChat::Whatsapp::Renderer::BUTTON_TITLE_LENGTH /
+      # LIST_ROW_TITLE_LENGTH). When truncation, or a duplicate label, would
+      # leave two titles indistinguishable, FlowChat::ChoiceTitles numbers
+      # every title in the set instead - which is what keeps them distinct,
+      # and why nothing here has to check for collisions itself. See its docs
+      # for why that decision is made once for the whole set.
+      #
+      class ChoiceMapper
+        def initialize(app)
+          @app = app
+          FlowChat.logger.debug { "Whatsapp::ChoiceMapper: Initialized WhatsApp choice mapping middleware" }
+        end
+
+        def call(context)
+          @context = context
+          @session = context.session
+
+          session_id = context["session.id"]
+          FlowChat.logger.debug { "Whatsapp::ChoiceMapper: Processing request for session #{session_id}" }
+
+          if intercept?
+            FlowChat.logger.info { "Whatsapp::ChoiceMapper: Intercepting request for choice resolution - session #{session_id}" }
+            handle_choice_input
+          end
+
+          # The maps belong to exactly one screen: this turn's, if it had a
+          # resolvable answer, or one that already fell out of use otherwise.
+          # Either way nothing here is still owed to the next screen, so they
+          # are cleared unconditionally rather than asked whether they still
+          # look "live" - create_id_mapping immediately below repopulates
+          # them whenever the app actually returns choices.
+          #
+          # An earlier version asked should_clear_for_new_flow? that question
+          # after handle_choice_input had already rewritten @context.input to
+          # the *resolved* value, which can equal one of the map's own keys
+          # (an Array choice's key is its label, and the wire value is the
+          # title built from that label), so the check answered
+          # "still live" about a value that was never a fresh reply. That let
+          # the maps survive into a free-text screen and reinterpret a typed
+          # answer there as the previous menu's choice. This was fixed once
+          # here in Task 6 and once for Messenger in Task 13; both fixes had
+          # the same shape and the same blind spot, which is why the guard is
+          # gone rather than patched a third time.
+          clear_choice_state
+
+          # Call the app (executor -> flow)
+          type, prompt, choices, media = @app.call(context)
+
+          # Transform choices if present (like USSD does)
+          if choices.present?
+            FlowChat.logger.debug { "Whatsapp::ChoiceMapper: Found choices, creating ID mapping" }
+            choices = create_id_mapping(choices)
+          end
+
+          [type, prompt, choices, media]
+        end
+
+        private
+
+        # Titles first, then positions. A tap sends the title as its payload
+        # and a user who types what they read sends the same string, so both
+        # arrive at the same entry - which is why there is no separate alias
+        # map any more. A position is the fallback, and only means anything
+        # when a number is genuinely on screen; it loses to a title because a
+        # choice labelled "1" would otherwise be unreachable.
+        def resolved_choice
+          input = @context.input.to_s
+          get_choice_mapping[input] || get_position_mapping[input]
+        end
+
+        def intercept?
+          # Intercept if user input matches a generated id or a stored position
+          should_intercept = @context.input.present? && resolved_choice.present?
+
+          if should_intercept
+            FlowChat.logger.debug { "Whatsapp::ChoiceMapper: Intercepting - input: #{@context.input}, mapped to: #{resolved_choice}" }
+          end
+
+          should_intercept
+        end
+
+        def handle_choice_input
+          original_choice = resolved_choice
+
+          FlowChat.logger.info { "Whatsapp::ChoiceMapper: Resolving choice input #{@context.input} to #{original_choice}" }
+
+          # Replace the generated ID (or typed position) with the original choice key
+          @context.input = original_choice
+        end
+
+        # The value WhatsApp sends back IS the displayed title.
+        # FlowChat::ChoiceTitles guarantees the titles in a set are distinct -
+        # numbering the whole set when they would not be - so a title needs no
+        # separate id space to be unique in, and there is nothing left for a
+        # generated id to collide with.
+        #
+        # This replaces an id generated by normalizing the label, which was
+        # lossy: stripping "!" turned "Yes!" into the id "Yes", which was
+        # another choice's label verbatim, and the id map was consulted before
+        # the alias map. Titles are also bounded by the rung's cap (20 button,
+        # 24 list row), comfortably inside WhatsApp's id caps of 256 and 200.
+        def create_id_mapping(choices)
+          cap = display_title_cap(choices.length)
+          return passthrough_mapping(choices) if cap.nil?
+
+          title_choices = {}
+          choice_mapping = {}
+
+          FlowChat::ChoiceTitles.build(choices, cap).each do |key, label, title, _truncated|
+            title_choices[title] = label
+            choice_mapping[title] = key
+          end
+
+          store_choice_mapping(choice_mapping)
+
+          if number_choices?(choices)
+            store_position_mapping(choices.keys.map.with_index(1) { |key, i| [i.to_s, key.to_s] }.to_h)
+          else
+            clear_position_mapping
+          end
+
+          title_choices
+        end
+
+        # Above the row cap the renderer numbers the body and prints each full
+        # label beside its number, so the label itself is what is on screen and
+        # stays resolvable - nothing is truncated, so there is no shortened
+        # form to key on instead.
+        #
+        # A label shared by two choices is dropped rather than resolved to the
+        # first of them. It identifies neither on a screen that shows both, and
+        # the number printed next to each is the reply that does.
+        def passthrough_mapping(choices)
+          labels = choices.map { |key, label| [label.to_s, key.to_s] }
+          repeated = labels.map(&:first).tally
+
+          store_choice_mapping(labels.reject { |label, _| repeated[label] > 1 }.to_h)
+          store_position_mapping(choices.keys.map.with_index(1) { |key, i| [i.to_s, key.to_s] }.to_h)
+          choices
+        end
+
+        # The title cap the renderer will use for these choices, or nil above
+        # the list cap, where the renderer falls back to a numbered body and
+        # shows the full label (no truncation, so no alias is needed).
+        #
+        # Goes through FlowChat::Meta::ChoiceLadder, the same helper
+        # FlowChat::Whatsapp::Renderer#build_interactive_message consults
+        # (via FlowChat::Config.whatsapp#ladder_limits), rather than
+        # re-deriving the rung from its own count comparisons: the mapper
+        # runs before the renderer and has no way to ask it which rung it
+        # chose, so both asking the same shared helper is what keeps them
+        # from disagreeing, the same reason Messenger's mapper does this too.
+        def display_title_cap(count)
+          case FlowChat::Meta::ChoiceLadder.rung_for(count, FlowChat::Config.whatsapp.ladder_limits)
+          when :quick_replies then FlowChat::Whatsapp::Renderer::BUTTON_TITLE_LENGTH
+          when :carousel then FlowChat::Whatsapp::Renderer::LIST_ROW_TITLE_LENGTH
+          end
+        end
+
+        # A position number is only worth resolving when one is genuinely on
+        # screen: above the row cap, where the renderer has no title left to
+        # show and numbers the body directly (display_title_cap is nil), or
+        # on a button/list rung whose titles FlowChat::ChoiceTitles decided
+        # were ambiguous and prefixed with a number. A short, unique set of
+        # titles (the common case) shows no number at all, so a typed digit
+        # there is free text, not a position.
+        def number_choices?(choices)
+          cap = display_title_cap(choices.length)
+          cap.nil? || FlowChat::ChoiceTitles.ambiguous?(choices, cap)
+        end
+
+        def store_choice_mapping(mapping)
+          @session.set("whatsapp.choice_mapping", mapping)
+          FlowChat.logger.debug { "Whatsapp::ChoiceMapper: Stored choice mapping: #{mapping}" }
+        end
+
+        def get_choice_mapping
+          @session.get("whatsapp.choice_mapping") || {}
+        end
+
+        def clear_choice_mapping
+          @session.delete("whatsapp.choice_mapping")
+          FlowChat.logger.debug { "Whatsapp::ChoiceMapper: Cleared choice mapping" }
+        end
+
+        def store_position_mapping(mapping)
+          @session.set("whatsapp.position_mapping", mapping)
+          FlowChat.logger.debug { "Whatsapp::ChoiceMapper: Stored position mapping: #{mapping}" }
+        end
+
+        def get_position_mapping
+          @session.get("whatsapp.position_mapping") || {}
+        end
+
+        def clear_position_mapping
+          @session.delete("whatsapp.position_mapping")
+        end
+
+        def clear_choice_state
+          clear_choice_mapping
+          clear_position_mapping
+        end
+      end
+    end
+  end
+end

data/lib/flow_chat/whatsapp/renderer.rb

@@ -1,6 +1,24 @@
+require "flow_chat/renderers/markdown_support"
+
 module FlowChat
   module Whatsapp
     class Renderer
+      include FlowChat::Renderers::MarkdownSupport
+
+      # WhatsApp button and list row title limits. The choice mapper reads
+      # these too, to alias the truncated title it knows this renderer will
+      # display for a given choice count.
+      BUTTON_TITLE_LENGTH = 20
+      LIST_ROW_TITLE_LENGTH = 24
+
+      # Meta: "Media asset caption text. Maximum 1024 characters." Documented
+      # for image, video, and document messages. Audio and sticker messages'
+      # own schemas list only id/link (audio also has voice) - no caption
+      # field at all - so they can never carry the numbered body this way,
+      # however short it is.
+      MAX_CAPTION_LENGTH = 1024
+      CAPTIONABLE_MEDIA_TYPES = [:image, :video, :document].freeze
+
       attr_reader :message, :choices, :media
 
       def initialize(message, choices: nil, media: nil)
@@ -24,25 +42,66 @@ module FlowChat
       private
 
       def build_text_message
-        [:text, message, {}]
+        [:text, to_whatsapp(message), {}]
+      end
+
+      def formatted_message
+        to_whatsapp(message)
+      end
+
+      def formatted_caption
+        message.present? ? to_whatsapp(message) : nil
       end
 
-      def build_media_message
+      # @param caption [String, nil] defaults to the prompt text. Pass nil when
+      #   this media is a companion sent ahead of a choice message: the prompt
+      #   is about to appear in that message's body, and a caption here would
+      #   just duplicate it.
+      def build_media_message(caption: formatted_caption)
         media_type = media[:type] || :image
-        url = media[:url] || media[:path]
+        url = media[:url]
+        id = media[:id]
         filename = media[:filename]
 
         case media_type.to_sym
         when :image
-          [:media_image, "", {url: url, caption: message}]
+          options = {}
+          options[:url] = url if url
+          options[:id] = id if id
+          options[:caption] = caption if caption
+          [:media_image, "", options]
         when :document
-          [:media_document, "", {url: url, caption: message, filename: filename}]
+          options = {}
+          options[:url] = url if url
+          options[:id] = id if id
+          options[:caption] = caption if caption
+          options[:filename] = filename if filename
+          [:media_document, "", options]
         when :audio
-          [:media_audio, "", {url: url, caption: message}]
+          options = {}
+          options[:url] = url if url
+          options[:id] = id if id
+          # Meta's audio message schema carries id, link and voice, with no
+          # caption, so a caption here would claim a field the API does not
+          # accept. Same as stickers below.
+          [:media_audio, "", options]
         when :video
-          [:media_video, "", {url: url, caption: message}]
+          options = {}
+          options[:url] = url if url
+          options[:id] = id if id
+          options[:caption] = caption if caption
+          [:media_video, "", options]
         when :sticker
-          [:media_sticker, "", {url: url}] # Stickers don't support captions
+          options = {}
+          options[:url] = url if url
+          options[:id] = id if id
+          [:media_sticker, "", options] # Stickers don't support captions
+        when :template
+          [:template, "", {
+            template_name: media[:template_name],
+            components: media[:components] || [],
+            language: media[:language] || "en_US"
+          }]
         else
           raise ArgumentError, "Unsupported media type: #{media_type}"
         end
@@ -56,56 +115,110 @@ module FlowChat
         end
       end
 
+      # Media is additive: it does not change which choice surface is used.
+      # 3 or fewer choices is the one case WhatsApp can carry both in a
+      # single message (buttons with a media header), so that stays as is.
+      # Above that, there is no interactive surface left that can carry
+      # media - Meta's interactive message reference documents header.type:
+      # text for list messages; image, video and document headers are only
+      # defined for button messages - so the media goes out as its own
+      # message and the list or numbered rendering follows unchanged.
+      #
+      # The one exception is the numbered rung above the list cap: there the
+      # choices are already nothing but text, and a captionable media
+      # message can carry that text itself, so a captioned single message
+      # replaces the media-then-text split whenever it fits.
       def build_selection_message_with_media
-        # Convert array to hash with index-based keys if needed, same as build_selection_message
+        choice_hash = normalized_choices
+
+        return build_buttons_message_with_media(choice_hash) if buttons_rung?(choice_hash.length)
+
+        type, content, options = build_interactive_message(choice_hash)
+
+        if type == :text
+          merged = media_caption_message(content)
+          return merged if merged
+        end
+
+        [type, content, options.merge(media: build_media_message(caption: nil))]
+      end
+
+      # Returns the single-message [type, content, options] triple when the
+      # media type can carry a caption and the combined text fits under
+      # Meta's cap, or nil when it does not - the caller falls back to the
+      # existing media-then-text split, which loses nothing.
+      def media_caption_message(content)
+        return nil unless CAPTIONABLE_MEDIA_TYPES.include?((media[:type] || :image).to_sym)
+        return nil if content.length > MAX_CAPTION_LENGTH
+
+        build_media_message(caption: content)
+      end
+
+      def normalized_choices
         if choices.is_a?(Array)
-          choice_hash = choices.each_with_index.to_h { |choice, index| [index.to_s, choice] }
-          build_buttons_message_with_media(choice_hash)
+          choices.each_with_index.to_h { |choice, index| [index.to_s, choice] }
         elsif choices.is_a?(Hash)
-          build_buttons_message_with_media(choices)
+          choices
         else
           raise ArgumentError, "choices must be an Array or Hash"
         end
       end
 
+      # Goes through FlowChat::Meta::ChoiceLadder, shared with Messenger and
+      # Instagram, rather than its own count comparisons - see
+      # FlowChat::Config::WhatsappConfig#ladder_limits for how WhatsApp's two
+      # flat thresholds are bridged to the shape that helper expects. The
+      # choice mapper asks the same question the same way, so the two cannot
+      # drift on which rung a given count lands on.
       def build_interactive_message(choice_hash)
-        if choice_hash.length <= 3
-          # Use buttons for 3 or fewer choices
-          build_buttons_message(choice_hash)
-        else
-          # Use list for more than 3 choices
-          build_list_message(choice_hash)
+        case FlowChat::Meta::ChoiceLadder.rung_for(choice_hash.length, limits.ladder_limits)
+        when :none, :quick_replies then build_buttons_message(choice_hash)
+        when :carousel then build_list_message(choice_hash)
+        when :numbered then build_numbered_message(choice_hash)
         end
       end
 
+      # :none (zero choices) counts as a buttons-rung count here, matching
+      # what the plain `count <= max_buttons` comparison this replaced did
+      # for zero: there is no real-world case with zero choices, but this
+      # keeps the two call sites in build_selection_message_with_media and
+      # build_interactive_message agreeing with each other regardless.
+      def buttons_rung?(count)
+        rung = FlowChat::Meta::ChoiceLadder.rung_for(count, limits.ladder_limits)
+        rung == :none || rung == :quick_replies
+      end
+
+      def limits
+        FlowChat::Config.whatsapp
+      end
+
+      # Whether titles are numbered, and the enumeration order positions come
+      # from, are both decided by FlowChat::ChoiceTitles over this same
+      # `choices` hash - the choice mapper goes through the same module over
+      # the same hash, so the two can never disagree on which titles are
+      # shown, which is what lets the mapper use a title as the wire value.
       def build_buttons_message(choices)
-        buttons = choices.map do |key, value|
-          {
-            id: key.to_s,
-            title: truncate_text(value.to_s, 20) # WhatsApp button titles have a 20 character limit
-          }
+        buttons = FlowChat::ChoiceTitles.build(choices, BUTTON_TITLE_LENGTH).map do |key, _label, title, _truncated|
+          {id: key, title: title}
         end
 
-        [:interactive_buttons, message, {buttons: buttons}]
+        [:interactive_buttons, formatted_message, {buttons: buttons}]
       end
 
       def build_buttons_message_with_media(choices)
-        buttons = choices.map do |key, value|
-          {
-            id: key.to_s,
-            title: truncate_text(value.to_s, 20) # WhatsApp button titles have a 20 character limit
-          }
+        buttons = FlowChat::ChoiceTitles.build(choices, BUTTON_TITLE_LENGTH).map do |key, _label, title, _truncated|
+          {id: key, title: title}
         end
 
         # Build media header
         header = build_media_header
 
-        [:interactive_buttons, message, {buttons: buttons, header: header}]
+        [:interactive_buttons, formatted_message, {buttons: buttons, header: header}]
       end
 
       def build_media_header
         media_type = media[:type] || :image
-        url = media[:url] || media[:path]
+        url = media[:url]
         filename = media[:filename]
 
         case media_type.to_sym
@@ -136,50 +249,132 @@ module FlowChat
         end
       end
 
+      # See the comment on build_buttons_message: numbering and position both
+      # come from FlowChat::ChoiceTitles over this same `choices` hash.
+      #
+      # The description (a longer, secondary line WhatsApp renders below the
+      # title, up to 72 chars) is not numbered: nothing resolves a typed
+      # description back to a choice, only the title and the position are
+      # aliased, so a prefix there would just be noise. It is populated
+      # whenever the title's own label portion didn't fit - whether that's
+      # because the label alone exceeds the cap, or because a position
+      # prefix ate into the room left for it.
       def build_list_message(choices)
-        items = choices.map do |key, value|
-          original_text = value.to_s
-          truncated_title = truncate_text(original_text, 24)
-
-          # If title was truncated, put full text in description (up to 72 chars)
-          description = if original_text.length > 24
-            truncate_text(original_text, 72)
-          end
+        items = FlowChat::ChoiceTitles.build(choices, LIST_ROW_TITLE_LENGTH).map do |key, label, title, truncated|
+          description = FlowChat::TextTruncator.truncate(label, 72) if truncated
 
           {
-            id: key.to_s,
-            title: truncated_title,
+            id: key,
+            title: title,
             description: description
           }.compact
         end
 
-        # If 10 or fewer items, use single section
-        sections = if items.length <= 10
-          [
-            {
-              title: "Options",
-              rows: items
-            }
-          ]
-        else
-          # Paginate into multiple sections (max 10 items per section)
-          items.each_slice(10).with_index.map do |section_items, index|
-            start_num = (index * 10) + 1
-            end_num = start_num + section_items.length - 1
-
-            {
-              title: "#{start_num}-#{end_num}",
-              rows: section_items
-            }
-          end
+        [:interactive_list, formatted_message, {sections: [{title: "Options", rows: items}]}]
+      end
+
+      # Above the row cap there is no interactive surface left, so the options go
+      # in the body and the user types a number. The choice mapper stores the
+      # positions for this rung so the digit resolves to the original key.
+      def build_numbered_message(choices)
+        numbered = choices.values.map.with_index(1) { |label, i| "#{i}. #{label}" }.join("\n")
+
+        [:text, "#{formatted_message}\n\n#{numbered}", {}]
+      end
+
+      # Convert text to WhatsApp format
+      # Processes markdown through HTML, then converts HTML tags to WhatsApp syntax
+      def to_whatsapp(text)
+        return "" if text.nil?
+
+        # Pre-process: handle markdown features not supported by standard kramdown
+        processed = preprocess_markdown(text.to_s)
+
+        # Convert markdown to HTML
+        html = Kramdown::Document.new(processed, **kramdown_options).to_html.strip
+        html_to_whatsapp(html)
+      end
+
+      # Handle markdown features not natively supported by kramdown
+      def preprocess_markdown(text)
+        result = text.dup
+
+        # Convert fenced code blocks to indented code blocks (kramdown native format)
+        # ```lang\ncode\n``` → indented with 4 spaces
+        result.gsub!(/^```\w*\n(.*?)^```/m) do
+          code = $1
+          code.lines.map { |line| "    #{line}" }.join
         end
 
-        [:interactive_list, message, {sections: sections}]
+        # Convert ~~strikethrough~~ to HTML <del> tags (kramdown will pass through)
+        result.gsub!(/~~([^~]+)~~/, '<del>\1</del>')
+
+        result
       end
 
-      def truncate_text(text, length)
-        return text if text.length <= length
-        text[0, length - 3] + "..."
+      # Convert HTML to WhatsApp formatting syntax
+      def html_to_whatsapp(html)
+        result = html.dup
+
+        # Convert code blocks first (before inline code)
+        # <pre><code>...</code></pre> → ```...```
+        result.gsub!(%r{<pre[^>]*><code[^>]*>(.*?)</code></pre>}m) { "```#{$1}```" }
+
+        # Convert inline code: <code>...</code> → `...`
+        result.gsub!(%r{<code[^>]*>(.*?)</code>}m) { "`#{$1}`" }
+
+        # Convert bold: <strong>...</strong> or <b>...</b> → *...*
+        result.gsub!(%r{<(?:strong|b)[^>]*>(.*?)</(?:strong|b)>}m) { "*#{$1}*" }
+
+        # Convert italic: <em>...</em> or <i>...</i> → _..._
+        result.gsub!(%r{<(?:em|i)[^>]*>(.*?)</(?:em|i)>}m) { "_#{$1}_" }
+
+        # Convert strikethrough: <s>...</s>, <del>...</del>, <strike>...</strike> → ~...~
+        result.gsub!(%r{<(?:s|del|strike)[^>]*>(.*?)</(?:s|del|strike)>}m) { "~#{$1}~" }
+
+        # Convert paragraphs to double newlines
+        result.gsub!(%r{<p[^>]*>(.*?)</p>}m) { "#{$1}\n\n" }
+
+        # Convert line breaks
+        result.gsub!(/<br\s*\/?>/, "\n")
+
+        # Convert links: <a href="url">text</a> → text (url)
+        # WhatsApp auto-links URLs, so we just show text and URL
+        result.gsub!(%r{<a[^>]*href=["']([^"']+)["'][^>]*>(.*?)</a>}m) do
+          url, text = $1, $2
+          (text == url) ? url : "#{text} (#{url})"
+        end
+
+        # Convert blockquotes (WhatsApp doesn't have native support, use > prefix)
+        result.gsub!(%r{<blockquote[^>]*>(.*?)</blockquote>}m) do
+          $1.lines.map { |line| "> #{line.strip}" }.join("\n")
+        end
+
+        # Convert lists
+        result.gsub!(%r{<ul[^>]*>(.*?)</ul>}m) do
+          items = $1.scan(%r{<li[^>]*>(.*?)</li>}m).flatten
+          items.map { |item| "• #{item.strip}" }.join("\n")
+        end
+        result.gsub!(%r{<ol[^>]*>(.*?)</ol>}m) do
+          items = $1.scan(%r{<li[^>]*>(.*?)</li>}m).flatten
+          items.map.with_index(1) { |item, i| "#{i}. #{item.strip}" }.join("\n")
+        end
+
+        # Strip any remaining HTML tags
+        result.gsub!(/<[^>]+>/, "")
+
+        # Decode HTML entities
+        result.gsub!("&amp;", "&")
+        result.gsub!("&lt;", "<")
+        result.gsub!("&gt;", ">")
+        result.gsub!("&quot;", '"')
+        result.gsub!("&#39;", "'")
+        result.gsub!("&nbsp;", " ")
+
+        # Clean up excessive newlines
+        result.gsub!(/\n{3,}/, "\n\n")
+
+        result.strip
       end
     end
   end

data/lib/flow_chat.rb

@@ -26,4 +26,4 @@ module FlowChat
   def self.metrics
     FlowChat::Instrumentation::Setup.metrics_collector
   end
-end
+end