aws-lex-conversation 3.0.0 → 4.0.2

data/lib/aws/lex/conversation/support/mixins/responses.rb

@@ -8,51 +8,45 @@ module Aws
           module Responses
             def close(opts = {})
               params = {
-                active_contexts: lex.active_contexts,
-                recent_intent_summary_view: pending_checkpoints,
-                session_attributes: lex.session_attributes
+                session_state: lex.session_state,
+                request_attributes: lex.request_attributes
               }.merge(opts)
               Response::Close.new(params).to_lex
             end
 
             def confirm_intent(opts = {})
               params = {
-                active_contexts: lex.active_contexts,
-                intent_name: lex.current_intent.name,
-                recent_intent_summary_view: pending_checkpoints,
-                session_attributes: lex.session_attributes,
-                slots: lex.current_intent.slots
+                session_state: lex.session_state,
+                request_attributes: lex.request_attributes,
+                intent: lex.current_intent
               }.merge(opts)
+              lex.session_state.intent = params.fetch(:intent)
               Response::ConfirmIntent.new(params).to_lex
             end
 
             def delegate(opts = {})
               params = {
-                active_contexts: lex.active_contexts,
-                recent_intent_summary_view: pending_checkpoints,
-                session_attributes: lex.session_attributes,
-                slots: lex.current_intent.slots
+                session_state: lex.session_state,
+                request_attributes: lex.request_attributes
               }.merge(opts)
               Response::Delegate.new(params).to_lex
             end
 
             def elicit_intent(opts = {})
               params = {
-                active_contexts: lex.active_contexts,
-                recent_intent_summary_view: pending_checkpoints,
-                session_attributes: lex.session_attributes
+                session_state: lex.session_state,
+                request_attributes: lex.request_attributes
               }.merge(opts)
               Response::ElicitIntent.new(params).to_lex
             end
 
             def elicit_slot(opts = {})
               params = {
-                active_contexts: lex.active_contexts,
-                intent_name: lex.current_intent.name,
-                recent_intent_summary_view: pending_checkpoints,
-                session_attributes: lex.session_attributes,
-                slots: lex.current_intent.slots
+                session_state: lex.session_state,
+                request_attributes: lex.request_attributes,
+                intent: lex.current_intent
               }.merge(opts)
+              lex.session_state.intent = params.fetch(:intent)
               Response::ElicitSlot.new(params).to_lex
             end
           end

data/lib/aws/lex/conversation/type/base.rb

@@ -26,10 +26,11 @@ module Aws
             end
 
             def to_lex
-              self.class.attributes.each_with_object({}) do |attribute, hash|
-                value = transform_to_lex(instance_variable_get("@#{attribute}"))
+              output = self.class.attributes.each_with_object({}) do |attribute, hash|
+                value = transform_to_lex(public_send(attribute))
                 hash[self.class.mapping.fetch(attribute)] = value
               end
+              output.compact
             end
 
             private
@@ -37,8 +38,13 @@ module Aws
             def transform_to_lex(value)
               case value
               when Hash
-                value.each_with_object({}) do |(key, val), hash|
-                  hash[key.to_sym] = transform_to_lex(val)
+                if value.respond_to?(:to_lex)
+                  value.to_lex
+                else
+                  output = value.each_with_object({}) do |(key, val), hash|
+                    hash[key.to_sym] = transform_to_lex(val)
+                  end
+                  output.compact
                 end
               when Array
                 value.map { |v| transform_to_lex(v) }

data/lib/aws/lex/conversation/type/bot.rb

@@ -7,8 +7,10 @@ module Aws
         class Bot
           include Base
 
+          required :alias_id
+          required :id
+          required :locale_id
           required :name
-          required :alias
           required :version
         end
       end

data/lib/aws/lex/conversation/type/checkpoint.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Aws
+  module Lex
+    class Conversation
+      module Type
+        class Checkpoint
+          include Base
+
+          required :dialog_action_type
+          required :intent
+
+          optional :label
+          optional :fulfillment_state
+          optional :slot_to_elicit
+
+          coerce(
+            intent: Intent,
+            dialog_action_type: DialogActionType,
+            fulfillment_state: FulfillmentState
+          )
+
+          # rubocop:disable Metrics/MethodLength
+          def restore(conversation, opts = {})
+            case dialog_action_type.raw
+            when 'Close'
+              conversation.close(
+                fulfillment_state: opts.fetch(:fulfillment_state) { fulfillment_state },
+                messages: opts.fetch(:messages)
+              )
+            when 'ConfirmIntent'
+              conversation.confirm_intent(
+                intent: intent,
+                messages: opts.fetch(:messages)
+              )
+            when 'Delegate'
+              conversation.delegate
+            when 'ElicitIntent'
+              conversation.elicit_intent(
+                messages: opts.fetch(:messages)
+              )
+            when 'ElicitSlot'
+              conversation.elicit_slot(
+                intent: intent,
+                messages: opts.fetch(:messages),
+                slot_to_elicit: slot_to_elicit
+              )
+            else
+              raise ArgumentError, "invalid DialogActionType: `#{dialog_action_type.raw}`"
+            end
+          end
+          # rubocop:enable Metrics/MethodLength
+        end
+      end
+    end
+  end
+end

data/lib/aws/lex/conversation/type/{confirmation_status.rb → confirmation_state.rb}

@@ -4,7 +4,7 @@ module Aws
   module Lex
     class Conversation
       module Type
-        class ConfirmationStatus
+        class ConfirmationState
           include Enumeration
 
           enumeration('None')

data/lib/aws/lex/conversation/type/context.rb

@@ -7,13 +7,13 @@ module Aws
         class Context
           include Base
 
-          required :time_to_live
+          required :context_attributes
           required :name
-          required :parameters
+          required :time_to_live
 
           coerce(
-            time_to_live: TimeToLive,
-            parameters: symbolize_hash!
+            context_attributes: symbolize_hash!,
+            time_to_live: TimeToLive
           )
         end
       end

data/lib/aws/lex/conversation/type/{slot_detail.rb → dialog_action.rb}

@@ -4,14 +4,14 @@ module Aws
   module Lex
     class Conversation
       module Type
-        class SlotDetail
+        class DialogAction
           include Base
 
-          required :resolutions
-          required :original_value
+          optional :slot_to_elicit
+          required :type
 
           coerce(
-            resolutions: Array[SlotResolution]
+            type: DialogActionType
           )
         end
       end

data/lib/aws/lex/conversation/type/dialog_action_type.rb

@@ -7,11 +7,11 @@ module Aws
         class DialogActionType
           include Enumeration
 
-          enumeration('ElicitIntent')
-          enumeration('ElicitSlot')
+          enumeration('Close')
           enumeration('ConfirmIntent')
           enumeration('Delegate')
-          enumeration('Close')
+          enumeration('ElicitIntent')
+          enumeration('ElicitSlot')
         end
       end
     end

data/lib/aws/lex/conversation/type/event.rb

@@ -7,36 +7,43 @@ module Aws
         class Event
           include Base
 
-          required :active_contexts, default: -> { [] }
-          required :alternative_intents, default: -> { [] }
-          required :current_intent
           required :bot
-          required :user_id
-          required :input_transcript
+          required :input_mode
+          required :input_transcript, default: -> { '' }
+          required :interpretations
           required :invocation_source
-          required :output_dialog_mode
           required :message_version
-          required :session_attributes
-          required :recent_intent_summary_view, default: -> { [] }
-          optional :request_attributes
-          optional :sentiment_response
-          optional :kendra_response
+          required :request_attributes, default: -> { {} }
+          required :response_content_type
+          required :session_id
+          required :session_state
+
+          computed_property :current_intent, ->(instance) do
+            instance.session_state.intent.tap do |intent|
+              intent.nlu_confidence = instance.interpretations.find { |i| i.intent.name == intent.name }.nlu_confidence
+            end
+          end
 
           computed_property :intents, ->(instance) do
-            [instance.current_intent] | instance.alternative_intents
+            instance.interpretations.map(&:intent).tap do |intents|
+              intents.map do |intent|
+                intent.nlu_confidence = instance.interpretations.find { |i| i.intent.name == intent.name }.nlu_confidence
+              end
+            end
+          end
+
+          computed_property :alternate_intents, ->(instance) do
+            instance.intents.reject { |intent| intent.name == instance.current_intent.name }
           end
 
           coerce(
-            active_contexts: Array[Context],
-            alternative_intents: Array[Intent],
-            current_intent: Intent,
             bot: Bot,
+            input_mode: InputMode,
+            interpretations: Array[Interpretation],
             invocation_source: InvocationSource,
-            output_dialog_mode: OutputDialogMode,
-            session_attributes: symbolize_hash!,
             request_attributes: symbolize_hash!,
-            recent_intent_summary_view: Array[RecentIntentSummaryView],
-            sentiment_response: SentimentResponse
+            response_content_type: Message::ContentType,
+            session_state: SessionState
           )
         end
       end

data/lib/aws/lex/conversation/type/{output_dialog_mode.rb → input_mode.rb}

@@ -4,10 +4,11 @@ module Aws
   module Lex
     class Conversation
       module Type
-        class OutputDialogMode
+        class InputMode
           include Enumeration
 
-          enumeration('Voice')
+          enumeration('DTMF')
+          enumeration('Speech')
           enumeration('Text')
         end
       end

data/lib/aws/lex/conversation/type/intent.rb

@@ -7,46 +7,37 @@ module Aws
         class Intent
           include Base
 
+          required :confirmation_state
+          optional :kendra_response
           required :name
           required :raw_slots, from: :slots, virtual: true
-          required :slot_details
-          required :confirmation_status
-          optional :nlu_intent_confidence_score
+          required :state
+          optional :originating_request_id
+          optional :nlu_confidence
 
           computed_property :slots, ->(instance) do
             # any keys indexed without a value will return an empty Slot instance
             default_hash = Hash.new do |_hash, key|
-              Slot.new(active: false, name: key.to_sym, value: nil, current_intent: instance)
+              Slot.shrink_wrap(active: false, name: key.to_sym, value: nil, shape: 'Scalar')
             end
 
             instance.raw_slots.each_with_object(default_hash) do |(key, value), hash|
+              normalized = value&.transform_keys(&:to_sym) || { shape: 'Scalar' }
               hash[key.to_sym] = Slot.shrink_wrap(
                 active: true,
                 name: key,
-                value: value,
-                # pass a reference to the parent down to the slot so that each slot
-                # instance can view a broader scope such as slot_details/resolutions
-                current_intent: instance
+                shape: normalized[:shape],
+                value: normalized[:value],
+                values: normalized[:values]
               )
             end
           end
 
-          class << self
-            def slot_details!
-              ->(val) do
-                val
-                  .compact
-                  .each_with_object({}) do |(key, value), hash|
-                    hash[key.to_sym] = SlotDetail.shrink_wrap(value)
-                  end
-              end
-            end
-          end
-
           coerce(
-            slot_details: slot_details!,
-            confirmation_status: ConfirmationStatus,
-            nlu_intent_confidence_score: float!(nilable: true)
+            raw_slots: symbolize_hash!,
+            slots: Array[Slot],
+            confirmation_state: ConfirmationState,
+            nlu_confidence: float!(nilable: true)
           )
         end
       end

data/lib/aws/lex/conversation/type/intent_confidence.rb

@@ -28,9 +28,9 @@ module Aws
           def candidates(threshold: standard_deviation)
             intents = event.intents.select do |intent|
               diff = event.current_intent
-                .nlu_intent_confidence_score
+                .nlu_confidence
                 .to_f
-                .-(intent.nlu_intent_confidence_score.to_f)
+                .-(intent.nlu_confidence.to_f)
                 .abs
 
               diff <= threshold
@@ -38,7 +38,7 @@ module Aws
 
             # sort descending
             intents.sort do |a, b|
-              b.nlu_intent_confidence_score.to_f <=> a.nlu_intent_confidence_score.to_f
+              b.nlu_confidence.to_f <=> a.nlu_confidence.to_f
             end
           end
 
@@ -58,13 +58,13 @@ module Aws
           private
 
           def calculate_mean
-            sum = event.intents.sum { |i| i.nlu_intent_confidence_score.to_f }
+            sum = event.intents.sum { |i| i.nlu_confidence.to_f }
             sum / event.intents.size
           end
 
           def calculate_standard_deviation
             normalized = event.intents.map do |intent|
-              (intent.nlu_intent_confidence_score.to_f - mean) ** 2
+              (intent.nlu_confidence.to_f - mean) ** 2
             end
             normalized_mean = normalized.sum / normalized.size
             Math.sqrt(normalized_mean)

data/lib/aws/lex/conversation/type/interpretation.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Aws
+  module Lex
+    class Conversation
+      module Type
+        class Interpretation
+          include Base
+
+          required :intent
+          optional :nlu_confidence
+          optional :sentiment_response
+
+          coerce(
+            intent: Intent,
+            nlu_confidence: float!(nilable: true),
+            sentiment_response: SentimentResponse
+          )
+        end
+      end
+    end
+  end
+end

data/lib/aws/lex/conversation/type/message.rb

@@ -7,11 +7,13 @@ module Aws
         class Message
           include Base
 
-          optional :content_type, default: 'PlainText'
+          required :content_type, default: -> { 'PlainText' }
           required :content
+          optional :image_response_card
 
           coerce(
-            content_type: Message::ContentType
+            content_type: Message::ContentType,
+            image_response_card: Aws::Lex::Conversation::Type::ResponseCard
           )
         end
       end