flow_chat 0.8.2 → 0.10.0

data/lib/flow_chat/whatsapp/gateway/cloud_api.rb

@@ -1,15 +1,14 @@
 require "net/http"
 require "json"
-require "openssl"
 
 module FlowChat
   module Whatsapp
-    # Configuration-related errors
-    class ConfigurationError < StandardError; end
-
     module Gateway
       class CloudApi
         include FlowChat::Instrumentation
+        include FlowChat::GatewayAsyncSupport
+        include FlowChat::Meta::SignatureValidation
+        include FlowChat::Meta::WebhookVerification
 
         attr_reader :context
 
@@ -24,84 +23,82 @@ module FlowChat
 
         def call(context)
           @context = context
-          controller = context.controller
-          request = controller.request
+          @controller = context.controller
+          request = @controller.request
 
           FlowChat.logger.debug { "CloudApi: Processing #{request.request_method} request to #{request.path}" }
 
-          # Handle webhook verification
-          if request.get? && request.params["hub.mode"] == "subscribe"
-            FlowChat.logger.info { "CloudApi: Handling webhook verification request" }
-            return handle_verification(context)
+          # Skip webhook-specific handling in background mode
+          unless in_background?
+            # Handle webhook verification
+            if request.get? && request.params["hub.mode"] == "subscribe"
+              FlowChat.logger.info { "CloudApi: Handling webhook verification request" }
+              return handle_verification(context)
+            end
           end
 
           # Handle webhook messages
           if request.post?
-            FlowChat.logger.info { "CloudApi: Handling webhook message" }
+            FlowChat.logger.info { "CloudApi: Handling webhook message (background: #{in_background?})" }
             return handle_webhook(context)
           end
 
           FlowChat.logger.warn { "CloudApi: Invalid request method or parameters - returning bad request" }
-          controller.head :bad_request
+          @controller.head :bad_request
         end
 
         # Expose client for out-of-band messaging
         attr_reader :client
 
-        private
+        # Configure WhatsApp-specific middleware stack
+        def self.configure_middleware_stack(builder, custom_middleware)
+          FlowChat.logger.debug { "CloudApi: Configuring WhatsApp middleware stack" }
 
-        def determine_message_handler(context)
-          # Check if simulator mode was already detected and set in context
-          if context["simulator_mode"]
-            FlowChat.logger.debug { "CloudApi: Using simulator message handler" }
-            return :simulator
-          end
+          builder.use custom_middleware
+          FlowChat.logger.debug { "CloudApi: Added custom middleware" }
 
-          # Use global WhatsApp configuration
-          mode = FlowChat::Config.whatsapp.message_handling_mode
-          FlowChat.logger.debug { "CloudApi: Using #{mode} message handling mode" }
-          mode
+          builder.use FlowChat::Whatsapp::Middleware::ChoiceMapper
+          FlowChat.logger.debug { "CloudApi: Added Whatsapp::Middleware::ChoiceMapper" }
         end
 
-        def handle_verification(context)
-          controller = context.controller
-          params = controller.request.params
+        # What this gateway is, for the shared Meta:: modules. Public because
+        # FlowChat::Meta::GatewayIdentity declares them public: a gateway saying
+        # which platform it speaks for is not a secret, unlike how it validates a
+        # signature. Keeping them here rather than below `private` means every
+        # Meta gateway answers these the same way.
+        def platform
+          :whatsapp
+        end
 
-          verify_token = @config.verify_token
-          provided_token = params["hub.verify_token"]
-          challenge = params["hub.challenge"]
+        def platform_label
+          "WhatsApp"
+        end
 
-          FlowChat.logger.debug { "CloudApi: Webhook verification - provided token matches: #{provided_token == verify_token}" }
+        def configuration_error_class
+          FlowChat::Whatsapp::ConfigurationError
+        end
 
-          if provided_token == verify_token
-            # Use instrumentation for webhook verification success
-            instrument(Events::WEBHOOK_VERIFIED, {
-              challenge: challenge,
-              platform: :whatsapp
-            })
+        private
 
-            controller.render plain: challenge
+        def determine_message_handler(context)
+          # Use simulator mode if enabled, otherwise always use inline
+          if context["simulator_mode"]
+            FlowChat.logger.debug { "CloudApi: Using simulator message handler" }
+            :simulator
           else
-            # Use instrumentation for webhook verification failure
-            instrument(Events::WEBHOOK_FAILED, {
-              reason: "Invalid verify token",
-              platform: :whatsapp
-            })
-
-            controller.head :forbidden
+            FlowChat.logger.debug { "CloudApi: Using inline message handler" }
+            :inline
           end
         end
 
         def handle_webhook(context)
-          controller = context.controller
-
           # Parse body
           begin
-            parse_request_body(controller.request)
+            parse_request_body(@controller.request)
             FlowChat.logger.debug { "CloudApi: Successfully parsed webhook request body" }
           rescue JSON::ParserError => e
             FlowChat.logger.error { "CloudApi: Failed to parse webhook body: #{e.message}" }
-            return controller.head :bad_request
+            return @controller.head :bad_request
           end
 
           # Check for simulator mode parameter in request (before validation)
@@ -112,154 +109,241 @@ module FlowChat
             context["simulator_mode"] = true
           end
 
-          # Validate webhook signature for security (skip for simulator mode)
-          unless is_simulator_mode || valid_webhook_signature?(controller.request)
-            FlowChat.logger.warn { "CloudApi: Invalid webhook signature received - rejecting request" }
-            return controller.head :unauthorized
+          # Validate webhook signature for security (skip for simulator mode and background)
+          # Return 200 OK even for invalid signatures to prevent WhatsApp from retrying
+          unless in_background? || is_simulator_mode || valid_webhook_signature?(@controller.request)
+            FlowChat.logger.warn { "CloudApi: Invalid webhook signature - dropping request" }
+            return @controller.head :ok
           end
 
           FlowChat.logger.debug { "CloudApi: Webhook signature validation passed" }
 
-          # Extract message data from WhatsApp webhook
-          entry = @body.dig("entry", 0)
-          unless entry
+          # A delivery can carry several accounts and several kinds of change at
+          # once, so every entry and every change gets looked at rather than only
+          # the first of each.
+          entries = @body["entry"]
+          unless entries.is_a?(Array) && entries.any?
             FlowChat.logger.debug { "CloudApi: No entry found in webhook body - returning OK" }
-            return controller.head :ok
-          end
-
-          changes = entry.dig("changes", 0)
-          unless changes
-            FlowChat.logger.debug { "CloudApi: No changes found in webhook entry - returning OK" }
-            return controller.head :ok
+            return @controller.head :ok
           end
 
-          value = changes["value"]
-          unless value
-            FlowChat.logger.debug { "CloudApi: No value found in webhook changes - returning OK" }
-            return controller.head :ok
-          end
-
-          # Handle incoming messages
-          if value["messages"]&.any?
-            message = value["messages"].first
-            contact = value["contacts"]&.first
-
-            phone_number = FlowChat::PhoneNumberUtil.to_e164(message["from"])
-            message_id = message["id"]
-            contact_name = contact&.dig("profile", "name")
-
-            context["request.id"] = phone_number
-            context["request.msisdn"] = phone_number
-            context["request.user_id"] = context["request.msisdn"]
-            context["request.gateway"] = :whatsapp_cloud_api
-            context["request.platform"] = :whatsapp
-            context["request.message_id"] = message_id
-            context["request.contact_name"] = contact_name
-            context["request.timestamp"] = message["timestamp"]
-
-            # Extract message content based on type
-            extract_message_content!(message, context)
-
-            if context.input.present?
-              # Use instrumentation for message received
-              instrument(Events::MESSAGE_RECEIVED, {
-                from: phone_number,
-                message: context.input,
-                message_type: message["type"],
-                message_id: message_id,
-              })
+          # Only one change per delivery can drive a flow, because only one can own
+          # the response to this request.
+          flow_ran = false
+
+          entries.each do |entry|
+            changes = entry["changes"]
+            next unless changes.is_a?(Array)
+
+            changes.each do |change|
+              value = change["value"]
+              next unless value.is_a?(Hash)
+
+              case webhook_field(change, value)
+              when "messages"
+                # There is no separate `statuses` field to subscribe to: Meta
+                # reports delivery status under `messages` as well, in a change
+                # carrying `statuses` and no `messages`. Handled before the flow
+                # slot is claimed, or a status arriving ahead of a message in the
+                # same delivery would spend the slot and drop the message.
+                #
+                # Foreground only. With async enabled the job re-enters this
+                # method on the same body, so publishing in both announced every
+                # status twice and delivery receipts double-counted. The request
+                # publishes them: it already holds the delivery, so a receipt is
+                # announced when it arrives rather than when the queue reaches
+                # it, and survives a job that is never picked up.
+                handle_statuses(value) if value["statuses"].present? && !in_background?
+
+                next if value["messages"].blank?
+
+                if flow_ran
+                  FlowChat.logger.warn { "CloudApi: A second messages change arrived in the same delivery and was not processed" }
+                  next
+                end
+                flow_ran = true
+
+                case handle_messages(context, value)
+                when :rejected then return @controller.head :forbidden
+                when :enqueued then return @controller.head :ok
+                when :rendered then return nil # simulator already wrote the response
+                end
+              when "statuses"
+                # Only reachable for a payload built without a field name, which
+                # our own fixtures do and Meta does not.
+                handle_statuses(value) unless in_background?
+              else
+                # Anything that is not a message or its delivery. Coexistence
+                # echoes, contact syncs, imported history, account bans, template
+                # approvals: all of it is the application's domain, so it is
+                # published rather than interpreted here.
+                handle_unmodelled_field(change["field"], value, entry["id"]) unless in_background?
+              end
             end
+          end
 
+          @controller.head :ok
+        end
 
-            FlowChat.logger.debug { "CloudApi: Message content extracted - Type: #{message["type"]}, Input: '#{context.input}'" }
+        # Meta names the change in `field`. Older payloads, and the ones our own
+        # tests build, leave it out, so fall back to what the value carries.
+        def webhook_field(change, value)
+          return change["field"] if change["field"].present?
+          return "messages" if value["messages"].is_a?(Array) && value["messages"].any?
+          return "statuses" if value["statuses"].is_a?(Array) && value["statuses"].any?
 
-            # Determine message handling mode
-            handler_mode = determine_message_handler(context)
+          nil
+        end
 
-            # Process the message based on handling mode
-            case handler_mode
-            when :inline
-              handle_message_inline(context, controller)
-            when :background
-              handle_message_background(context, controller)
-            when :simulator
-              # Return early from simulator mode to preserve the JSON response
-              return handle_message_simulator(context, controller)
-            end
+        # Returns what happened, so the caller can decide whether it still owns the
+        # response: :rejected, :enqueued, :rendered, :processed or :skipped.
+        def handle_messages(context, value)
+          message = value["messages"]&.first
+          return :skipped unless message
+
+          contact = value["contacts"]&.first
+
+          phone_number = FlowChat::PhoneNumberUtil.to_e164(message["from"])
+          message_id = message["id"]
+          contact_name = contact&.dig("profile", "name")
+          business_phone_number = value.dig("metadata", "display_phone_number")
+          business_phone_number_id = value.dig("metadata", "phone_number_id")
+
+          # Validate that webhook is for our configured phone number. Skipped
+          # in simulator mode rather than requiring the simulator to send an
+          # id that matches a real configuration: the simulator's whole
+          # point is running a turn with no live credentials at hand. Safe
+          # to skip, not a hole for real traffic, because
+          # context["simulator_mode"] is only ever true once simulate? has
+          # already checked the signed simulator cookie, above in
+          # handle_webhook.
+          if !context["simulator_mode"] && business_phone_number_id != @config.phone_number_id
+            FlowChat.logger.warn { "CloudApi: Webhook received for phone_number_id '#{business_phone_number_id}' but configured for '#{@config.phone_number_id}' - rejecting" }
+            return :rejected
           end
 
-          # Handle message status updates
-          if value["statuses"]&.any?
-            statuses = value["statuses"]
-            FlowChat.logger.info { "CloudApi: Received #{statuses.size} status update(s)" }
-            FlowChat.logger.debug { "CloudApi: Status updates: #{statuses.inspect}" }
+          context["request.id"] = phone_number
+          context["request.user_id"] = phone_number
+          context["request.user_name"] = contact_name if contact_name
+          context["request.msisdn"] = phone_number
+          context["request.gateway"] = :whatsapp_cloud_api
+          context["request.platform"] = :whatsapp
+          context["request.message_id"] = message_id
+          context["request.timestamp"] = Time.current.iso8601
+          context["request.body"] = @body
+
+          context["whatsapp.business.phone_number"] = FlowChat::PhoneNumberUtil.to_e164(business_phone_number)
+          context["whatsapp.business.phone_number_id"] = business_phone_number_id
+          context["whatsapp.client"] = @client
+
+          # Extract message content based on type
+          extract_message_content!(message, context)
+
+          if inbound_message?(context)
+            # Use instrumentation for message received
+            instrument(Events::MESSAGE_RECEIVED, {
+              from: phone_number,
+              message: context.input,
+              message_type: message["type"],
+              message_id: message_id
+            })
           end
 
-          controller.head :ok
-        end
-
-        # Validate webhook signature to ensure request comes from WhatsApp
-        def valid_webhook_signature?(request)
-          # Check if signature validation is explicitly disabled
-          if @config.skip_signature_validation
-            FlowChat.logger.debug { "CloudApi: Webhook signature validation is disabled" }
-            return true
-          end
+          FlowChat.logger.debug { "CloudApi: Message content extracted - Type: #{message["type"]}, Input: '#{context.input}'" }
 
-          # Require app_secret for signature validation
-          unless @config.app_secret && !@config.app_secret.empty?
-            error_msg = "WhatsApp app_secret is required for webhook signature validation. " \
-                       "Either configure app_secret or set skip_signature_validation=true to explicitly disable validation."
-            FlowChat.logger.error { "CloudApi: #{error_msg}" }
-            raise FlowChat::Whatsapp::ConfigurationError, error_msg
+          # Determine routing: async enqueue, background execute, or inline
+          if should_enqueue_async?
+            # Webhook with async enabled → enqueue job and return immediately
+            enqueue_async_job
+            return :enqueued
           end
 
-          signature_header = request.headers["X-Hub-Signature-256"]
-          unless signature_header
-            FlowChat.logger.warn { "CloudApi: No X-Hub-Signature-256 header found in request" }
-            return false
+          # Background OR inline → process message
+          case determine_message_handler(context)
+          when :inline
+            handle_message_inline(context, @controller)
+            :processed
+          when :simulator
+            handle_message_simulator(context, @controller)
+            :rendered
           end
+        end
 
-          # Extract signature from header (format: "sha256=<signature>")
-          expected_signature = signature_header.sub("sha256=", "")
-
-          # Get raw request body
-          request.body.rewind
-          body = request.body.read
-          request.body.rewind
-
-          # Calculate HMAC signature
-          calculated_signature = OpenSSL::HMAC.hexdigest(
-            OpenSSL::Digest.new("sha256"),
-            @config.app_secret,
-            body
-          )
-
-          # Compare signatures using secure comparison to prevent timing attacks
-          signature_valid = secure_compare(expected_signature, calculated_signature)
-
-          if signature_valid
-            FlowChat.logger.debug { "CloudApi: Webhook signature validation successful" }
-          else
-            FlowChat.logger.warn { "CloudApi: Webhook signature validation failed - signatures do not match" }
+        def handle_statuses(value)
+          statuses = value["statuses"]
+          return if statuses.blank?
+
+          FlowChat.logger.info { "CloudApi: Received #{statuses.size} status update(s)" }
+          FlowChat.logger.debug { "CloudApi: Status updates: #{statuses.inspect}" }
+
+          statuses.each do |status|
+            instrument(Events::MESSAGE_STATUS, {
+              platform: :whatsapp,
+              gateway: :whatsapp_cloud_api,
+              business_phone_number_id: value.dig("metadata", "phone_number_id"),
+              message_id: status["id"],
+              recipient: status["recipient_id"],
+              status: status["status"],
+              timestamp: status["timestamp"],
+              errors: status["errors"],
+              # Meta reports more about a delivery than a status and a time: what
+              # it billed the conversation as, and its own view of the window.
+              # None of it is this gem's business to interpret, and all of it is
+              # gone if the named keys are the only way through.
+              value: status
+            })
           end
-
-          signature_valid
-        rescue FlowChat::Whatsapp::ConfigurationError
-          raise
-        rescue => e
-          FlowChat.logger.error { "CloudApi: Error validating webhook signature: #{e.class.name}: #{e.message}" }
-          false
         end
 
-        # Secure string comparison to prevent timing attacks
-        def secure_compare(a, b)
-          return false unless a.bytesize == b.bytesize
+        # Everything that is not a message or its delivery. Verified, named, and
+        # handed on whole for the application to make sense of.
+        #
+        # The account id comes from the entry rather than the value because a change
+        # about the account itself names no phone number: a ban, a review outcome, a
+        # template approval. Without it those arrive identifying nothing, and an
+        # application holding several businesses cannot tell whose they are.
+        def handle_unmodelled_field(field, value, business_account_id)
+          FlowChat.logger.info {
+            "CloudApi: Publishing webhook field '#{field}' (value keys: #{value.keys.join(", ")})"
+          }
+
+          payload = {
+            platform: :whatsapp,
+            gateway: :whatsapp_cloud_api,
+            field: field,
+            business_account_id: business_account_id,
+            business_phone_number: value.dig("metadata", "display_phone_number"),
+            business_phone_number_id: value.dig("metadata", "phone_number_id"),
+            value: value
+          }
+
+          origin = echo_origin(field, value)
+          payload[:echo_origin] = origin if origin
+
+          instrument(Events::WEBHOOK_RECEIVED, payload)
+        end
 
-          l = a.unpack("C*")
-          res = 0
-          b.each_byte { |byte| res |= byte ^ l.shift }
-          res == 0
+        # An echo reports a message sent on the thread by someone other than the
+        # user we are talking to. Which someone matters: a human replying from the
+        # business inbox usually means the application should stand the flow
+        # down, while our own send coming back means nothing at all. Only the
+        # app_id separates them, and only this gateway knows our own, so it is
+        # derived here rather than left for every subscriber to work out.
+        #
+        # Meta names the coexistence echo field "smb_message_echoes" and nests the
+        # echoes themselves under "message_echoes"; both are matched precisely
+        # rather than by a loose "echo" substring or "first array in the value",
+        # since a field this gateway does not otherwise interpret could carry
+        # other arrays under other names.
+        def echo_origin(field, value)
+          return nil unless field == "smb_message_echoes"
+
+          app_id = value["message_echoes"]&.first&.dig("app_id")
+
+          return :human_agent if app_id.blank?
+          return :self if app_id.to_s == @config.app_id.to_s
+
+          :other_app
         end
 
         def extract_message_content!(message, context)
@@ -269,7 +353,7 @@ module FlowChat
           case message_type
           when "text"
             content = message.dig("text", "body")
-            context.input = content
+            context.input = content.presence || ""
             FlowChat.logger.debug { "CloudApi: Text message content: '#{content}'" }
           when "interactive"
             # Handle button/list replies
@@ -290,70 +374,96 @@ module FlowChat
               address: message.dig("location", "address")
             }
             context["request.location"] = location
-            context.input = "$location$"
+            context.input = ""
             FlowChat.logger.debug { "CloudApi: Location received - Lat: #{location[:latitude]}, Lng: #{location[:longitude]}" }
-          when "image", "document", "audio", "video"
+          when "image", "document", "audio", "video", "sticker"
+            media_data = message[message["type"]]
             context["request.media"] = {
-              type: message["type"],
-              id: message.dig(message["type"], "id"),
-              mime_type: message.dig(message["type"], "mime_type"),
-              caption: message.dig(message["type"], "caption")
+              type: message["type"].to_sym,
+              id: media_data["id"],
+              mime_type: media_data["mime_type"],
+              caption: media_data["caption"],
+              filename: media_data["filename"],
+              sha256: media_data["sha256"],
+              animated: media_data["animated"]
             }
-            context.input = "$media$"
+            # The caption (if any) is the turn's text; a text-less media message has blank input.
+            context.input = media_data["caption"].presence || ""
+            FlowChat.logger.debug { "CloudApi: Media received - Type: #{message["type"]}, ID: #{media_data["id"]}" }
+          when "contacts"
+            # WhatsApp sends contacts as an array, take the first one
+            contact_data = message.dig("contacts", 0)
+            if contact_data
+              phones = contact_data.dig("phones") || []
+              context["request.contact"] = {
+                name: contact_data.dig("name", "formatted_name"),
+                first_name: contact_data.dig("name", "first_name"),
+                last_name: contact_data.dig("name", "last_name"),
+                phones: phones.map { |p| p["phone"] },
+                phone_number: phones.first&.dig("phone")
+              }
+              context.input = ""
+              FlowChat.logger.debug { "CloudApi: Contact received - Name: #{context["request.contact"][:name]}" }
+            end
           end
         end
 
         def handle_message_inline(context, controller)
           response = @app.call(context)
           if response
-            _type, prompt, choices, media = response
-            rendered_message = render_response(prompt, choices, media)
-            result = @client.send_message(context["request.msisdn"], rendered_message)
+            type, prompt, choices, media = response
+            result = report_delivery_failure(
+              context,
+              to: context["request.msisdn"],
+              session_id: context["request.id"],
+              message: prompt,
+              message_type: (type == :prompt) ? "prompt" : "terminal",
+              gateway: :whatsapp_cloud_api,
+              platform: :whatsapp
+            ) do
+              @client.send_message(context["request.msisdn"], prompt, choices: choices, media: media)
+            end
             context["whatsapp.message_result"] = result
+
+            # report_delivery_failure already reported this; a nil result
+            # means the platform did not accept the message, and instrumenting
+            # MESSAGE_SENT anyway counted a delivery that never happened.
+            return unless result
+
+            # Instrument message sent
+            instrument(Events::MESSAGE_SENT, {
+              to: context["request.msisdn"],
+              session_id: context["request.id"],
+              message: prompt,
+              message_type: (type == :prompt) ? "prompt" : "terminal",
+              gateway: :whatsapp_cloud_api,
+              platform: :whatsapp,
+              content_length: prompt.to_s.length,
+              # What Meta called it, so this and message.status can be joined.
+              platform_message_id: platform_message_id_from(result),
+              duration_ms: context[FlowChat::Instrumentation::DELIVERY_DURATION_KEY],
+              timestamp: context["request.timestamp"]
+            })
           end
         end
 
-        def handle_message_background(context, controller)
-          # Process the flow synchronously (maintaining controller context)
-          response = @app.call(context)
-
-          if response
-            _type, prompt, choices, media = response
-            rendered_message = render_response(prompt, choices, media)
-
-            # Queue only the response delivery asynchronously
-            send_data = {
-              msisdn: context["request.msisdn"],
-              response: rendered_message,
-              config_name: @config.name
-            }
+        # Meta answers a send with the ids it assigned.
+        def platform_message_id_from(result)
+          return nil unless result.is_a?(Hash)
 
-            # Get job class from configuration
-            job_class_name = FlowChat::Config.whatsapp.background_job_class
-
-            # Enqueue background job for sending only
-            begin
-              job_class = job_class_name.constantize
-              job_class.perform_later(send_data)
-            rescue NameError
-              # Fallback to inline sending if no job system
-              Rails.logger.warn "Background mode requested but no #{job_class_name} found. Falling back to inline sending."
-              result = @client.send_message(context["request.msisdn"], rendered_message)
-              context["whatsapp.message_result"] = result
-            end
-          end
+          result.dig("messages", 0, "id")
         end
 
         def handle_message_simulator(context, controller)
           response = @app.call(context)
 
           if response
-            _type, prompt, choices, media = response
-            rendered_message = render_response(prompt, choices, media)
+            _, prompt, choices, media = response
+            response_data = render_response(prompt, choices, media)
 
             # For simulator mode, return the response data in the HTTP response
             # instead of actually sending via WhatsApp API
-            message_payload = @client.build_message_payload(rendered_message, context["request.msisdn"])
+            message_payload = @client.build_message_payload(response_data, context["request.msisdn"])
 
             simulator_response = {
               mode: "simulator",
@@ -361,7 +471,7 @@ module FlowChat
               would_send: message_payload,
               message_info: {
                 to: context["request.msisdn"],
-                contact_name: context["request.contact_name"],
+                contact_name: context["request.user_name"],
                 timestamp: Time.now.iso8601
               }
             }
@@ -375,46 +485,23 @@ module FlowChat
           # Check if simulator mode is enabled for this processor
           return false unless context["enable_simulator"]
 
-          # Then check if simulator mode is requested and valid
-          @body.dig("simulator_mode") && valid_simulator_cookie?(context)
+          # Then check if simulator mode is requested and authorized
+          @body.dig("simulator_mode") &&
+            FlowChat::Security.valid_simulator_cookie?(@controller.request.cookies[FlowChat::Security::SIMULATOR_COOKIE_NAME])
         end
 
-        def valid_simulator_cookie?(context)
-          simulator_secret = FlowChat::Config.simulator_secret
-          return false unless simulator_secret && !simulator_secret.empty?
-
-          # Check for simulator cookie
-          request = context.controller.request
-          simulator_cookie = request.cookies["flowchat_simulator"]
-          return false unless simulator_cookie
+        def parse_request_body(request)
+          return @body if @body
 
-          # Verify the cookie is a valid HMAC signature
-          # Cookie format: "timestamp:signature" where signature = HMAC(simulator_secret, "simulator:timestamp")
-          begin
-            timestamp_str, signature = simulator_cookie.split(":", 2)
-            return false unless timestamp_str && signature
-
-            # Check timestamp is recent (within 24 hours for reasonable session duration)
-            timestamp = timestamp_str.to_i
-            return false if timestamp <= 0
-            return false if (Time.now.to_i - timestamp).abs > 86400 # 24 hours
-
-            # Calculate expected signature
-            message = "simulator:#{timestamp_str}"
-            expected_signature = OpenSSL::HMAC.hexdigest(OpenSSL::Digest.new("sha256"), simulator_secret, message)
-
-            # Use secure comparison
-            secure_compare(signature, expected_signature)
-          rescue => e
-            Rails.logger.warn "Invalid simulator cookie format: #{e.message}"
-            false
+          if request.body.nil?
+            FlowChat.logger.debug { "CloudApi: Request body is nil, returning empty hash" }
+            @body = {}
+          else
+            request.body.rewind if request.body.respond_to?(:rewind)
+            @body = JSON.parse(request.body.read)
           end
         end
 
-        def parse_request_body(request)
-          @body ||= JSON.parse(request.body.read)
-        end
-
         def render_response(prompt, choices, media)
           FlowChat::Whatsapp::Renderer.new(prompt, choices: choices, media: media).render
         end