Here's how I solved a number of issues

[danielbrunt57]

Is your feature request related to a problem? Please describe.
Sort of except it's not a feature request but a "Here's how I solved the delay issue in updating last_alexa!"
It's been very annoying to have to add hard-coded delays to scripts following the alexa_media.update_last_called service call to update the last called Alexa. The delays were required to permit the integration time to update the media_players last_called and last_called_timestamps which now do not seem to occur in a timely fashion thus making the service call essential, but there was no way to determine when that process finished, or if it even took place due to no change being necessary, but, I think I've finally solved it.

Describe the solution you'd like
Provide additional info in the wiki to include a new attribute last_updated_timestamp which can then be used as a trigger to permit scripts/automations to wait for a change in that timestamp and then proceed when it occurs, with an appropriate default timeout as a failsafe.

Since I've implemented my new logic for calling all these scripts, my notifications (actionable or otherwise) can now proceed much quicker and I've not had any failures in targeting the correct last called alexa device.

The other thing I overcame a while ago was multiple notifications occurring and interrupting the previous one still speaking.

Additional context
The first step I did was to create a single queued script that I invoke for all notifications (except actionable). It counts the number of words to be uttered and waits for that word count x 0.4 seconds (which seemed to be a good average for my utterances) before ending and executing the next one.

alias: "Alexa: Notify Alexa Media"
description: Send notification to sensor.last_alexa
fields:
  message:
    description: The message content
    example: I am notifying you
sequence:
  - service: notify.alexa_media
    continue_on_error: true
    data:
      message: "{{ message }}"
      data:
        type: tts
      target: "{{ states('sensor.last_alexa') }}"
  - delay:
      seconds: "{{ (message.split(' ') | count * 0.4 ) | round(0, 'floor', default) }}"
mode: queued
icon: mdi:account-voice
max: 10

Actionable notifications are also queued but do not have to count words:

alias: "Alexa: Activate Actionable Notification"
description: Activates an actionable notification on a specific echo device
fields:
  text:
    description: The text you would like alexa to speak.
    example: What would you like the thermostat set to?
  event_id:
    description: Correlation ID for event responses
    example: ask_for_temperature
  alexa_device:
    description: Alexa device you want to trigger
    example: media_player.new_white_echo_dot
  suppress_confirmation:
    description: Set true if you want to suppress 'okay' confirmation
    example: "true"
sequence:
  - service: input_text.set_value
    entity_id: input_text.alexa_actionable_notification
    data:
      value: "{\"text\": \"{{ text }}\", \"event\": \"{{ event_id }}\" }"
    target:
      entity_id: input_text.alexa_actionable_notification
  - service: media_player.play_media
    target:
      entity_id: "{{ alexa_device }}"
    data:
      media_content_type: skill
      media_content_id: amzn1.ask.skill.6b2071e3-0f30-4fcf-b3d3-65631de50fd2
  - wait_for_trigger:
      - platform: event
        event_type: alexa_actionable_notification
    timeout:
      hours: 0
      minutes: 0
      seconds: 30
      milliseconds: 0
    enabled: true
mode: queued
max: 10

This is the script that gets called to update last_alexa at the beginning of all scripts & automations which invoke either alexa notifications or actionable notifications:

alias: "Alexa: Update sensor.last_alexa - wait for tmestamp to update"
sequence:
  - service: alexa_media.update_last_called
    data: {}
  - wait_for_trigger:
      - platform: state
        entity_id:
          - sensor.last_alexa
        attribute: last_called_timestamp
    timeout:
      hours: 0
      minutes: 0
      seconds: 15
      milliseconds: 0
mode: single

This is the key piece for the previous script - Add a last_called_timestamp attribute to the sensor.last_alexa template:

  - name: "{{ states.media_player | selectattr('attributes.last_called', 'defined') | selectattr('attributes.last_called','eq',true) | map(attribute='name') | first | default(none) }}"
    unique_id: last_alexa
    state: "{{ states.media_player | selectattr('attributes.last_called', 'defined') | selectattr('attributes.last_called','eq',true) | map(attribute='entity_id') | first | default(none) }}"
    attributes:
      last_called_timestamp: >
        {{ states.media_player | selectattr('attributes.last_called', 'defined') | selectattr('attributes.last_called','eq',true) | map(attribute='attributes.last_called_timestamp') | first | default(none) }}

I can now execute my good_night/morning scripts with multiple actions running in parallel and they all execute much faster and do not interrupt previous utterances in progress or say the wrong phrase in an actionable one or wait excessively:

alias: Good Night
sequence:
  - service: script.update_last_alexa_and_wait
    data: {}
    alias: Call a service - script.update_last_alexa_and_wait
  - parallel:
      - if:
          - condition: state
            entity_id: input_boolean.coffee_prepared
            state: "off"
        then:
          - service: script.activate_alexa_actionable_notification
            data:
              text: Did you prepare your coffee?
              event_id: actionable_notification_coffee_prepared
              alexa_device: "{{ states('sensor.last_alexa') }}"
          - wait_for_trigger:
              - platform: event
                event_type: alexa_actionable_notification
            timeout: "00:00:20"
            enabled: false
      - if:
          - condition: not
            conditions:
              - condition: state
                entity_id: climate.living_room
                attribute: preset_mode
                state: eco
                alias: Preset of Furnace
            alias: If Preset of Furnace is NOT  'eco'
          - condition: numeric_state
            entity_id: climate.living_room
            attribute: temperature
            above: 17
            alias: Furnace temperature is above 17
        then:
          - service: climate.set_temperature
            data:
              temperature: 17
            target:
              entity_id: climate.living_room
          - service: script.notify_alexa_media
            data:
              message: Heat is now set to 17
      - service: media_player.turn_off
        target:
          area_id:
            - living_room
            - bedroom
        data: {}
      - if:
          - condition: state
            entity_id: lock.front_door_lock
            state: unlocked
        then:
          - service: lock.lock
            data: {}
            target:
              entity_id: lock.front_door_lock
          - service: script.notify_alexa_media
            data:
              message: The front door was unlocked but I locked it for you.
      - choose:
          - conditions:
              - condition: state
                entity_id: input_boolean.garbage_is_out
                state: "off"
              - condition: or
                conditions:
                  - condition: and
                    conditions:
                      - condition: state
                        entity_id: sensor.garbage
                        state: "0"
                      - condition: time
                        before: "09:00:00"
                        weekday:
                          - wed
                        after: "00:00:00"
                  - condition: and
                    conditions:
                      - condition: state
                        entity_id: sensor.garbage
                        state: "1"
                      - condition: time
                        after: "12:00:00"
                        weekday:
                          - tue
                        before: "00:00:00"
            sequence:
              - service: script.activate_alexa_actionable_notification
                data:
                  text: Did you put the garbage out?
                  event_id: actionable_notification_garbage_pickup
                  alexa_device: "{{ states(\"sensor.last_alexa\") }}"
              - wait_for_trigger:
                  - platform: event
                    event_type: alexa_actionable_notification
                timeout: "00:00:10"
      - if:
          - condition: state
            entity_id: cover.garage_door
            state: open
        then:
          - if:
              - condition: state
                entity_id: sensor.season
                state: summer
            then:
              - service: script.notify_alexa_media
                data:
                  message: Hey. Did you know the garage door is open?
                  milliseconds: 0
            else:
              - service: cover.close_cover
                data:
                  entity_id: cover.garage_door
              - service: script.notify_alexa_media
                data:
                  message: I closed the garage door for you
                  milliseconds: 0
      - choose:
          - conditions:
              - condition: state
                entity_id: input_boolean.recycling_is_out
                state: "off"
              - condition: or
                conditions:
                  - condition: and
                    conditions:
                      - condition: state
                        entity_id: sensor.recycling
                        state: "0"
                      - condition: time
                        before: "09:00:00"
                        weekday:
                          - thu
                          - fri
                        after: "00:00:00"
                  - condition: and
                    conditions:
                      - condition: state
                        entity_id: sensor.recycling
                        state: "1"
                      - condition: time
                        after: "12:01:00"
                        weekday:
                          - wed
                          - thu
                        before: "00:00:00"
            sequence:
              - service: script.activate_alexa_actionable_notification
                data:
                  text: Did you put the recycling out?
                  event_id: actionable_notification_recycling_pickup
                  alexa_device: "{{ states('sensor.last_alexa') }}"
              - wait_for_trigger:
                  - platform: event
                    event_type: alexa_actionable_notification
                timeout: "00:00:10"
                enabled: false
      - service: input_select.select_option
        data:
          option: Sleeping
        target:
          entity_id: input_select.sleep_status
      - service: input_boolean.turn_on
        data: {}
        target:
          entity_id:
            - input_boolean.sleep_mode
            - input_boolean.daniel_sleeping
      - service: input_number.set_value
        data:
          value: 0
        target:
          entity_id: input_number.bathroom_delay_off
  - service: light.turn_off
    data:
      transition: 15
    target:
      entity_id: light.bedroom_lighting
  - delay:
      hours: 0
      minutes: 0
      seconds: 10
      milliseconds: 0
  - parallel:
      - service: media_player.play_media
        continue_on_error: true
        data:
          media_content_id: Alexa.GoodNight.Play
          media_content_type: sequence
        target:
          entity_id: "{{ states(\"media_player.last_alexa\") }}"
        alias: "Media Player: Say Goodnight"
      - service: light.turn_off
        target:
          area_id:
            - bathroom
        data: {}
      - if:
          - condition: state
            entity_id: cover.south_patio_door
            state: open
        then:
          - service: cover.close_cover
            data: {}
            target:
              entity_id: cover.south_patio_door
        enabled: false
  - service: script.enable_alarm
    data: {}
    enabled: false
mode: single
icon: hass:weather-night

[alandtse]

Thanks. Converted to a discussion. You are already able to edit the wiki so please feel free to just add this in there and you can then close this too.

[danielbrunt57]

With the recent HTTP2 fix to Alexa media, I'm finding that the update last_alexa is no longer necessary as last_alexa seems to be updating almost instantly now, even quicker than before, and the timestamp I added may no longer have any useful benefit. The sequential script to execute notifications though is still useful to prevent them from interrupting each other.