Add script.execute_sync action or configurable blocking mode for scripts

[AndreiArdelean1]

Component name

script

Link to component documentation on our website

https://esphome.io/components/script

Describe the enhancement

Currently, calling a script via script.execute is asynchronous. To wait until a script finishes, you have to pair it manually with script.wait, e.g.:

- script.execute:
    id: my_script
- script.wait: my_script

This works but is repetitive and unintuitive for users who want scripts to behave like traditional synchronous functions.

I propose either:

1. A new action script.execute_sync that automatically waits until the script finishes:

- script.execute_sync:
    id: my_script
    duration: 1000

2. Or a configuration option on the script itself (e.g., blocking: true) that makes script.execute wait automatically:

script:
  - id: my_script
    blocking: true
    then:
      - switch.turn_on: relay1
      - delay: 1000ms
      - switch.turn_off: relay1

Use cases

This is useful for sequences where multiple switches or GPIOs must be turned on/off in order with delays between them. For example:

• Run sequence1 -> perform a specific GPIO pattern (e.g., blink a relay quickly 3 times)
• Delay
• Run sequence2 -> perform another GPIO pattern (e.g., blink slowly 5 times)
• Delay
• Reset -> return all GPIOs to their default state

In my particular case, I need to turn a specific relay on for a fixed duration and then turn it off, ensuring it always returns to the off state, and combining them in a bigger script.

Currently, achieving this requires manually pairing script.execute with script.wait for each step, which is repetitive and prone to mistakes. A built-in blocking mechanism would make these sequential automations much simpler, safer, and more readable.

Anything else?

• This enhancement would make scripts behave more like traditional functions in programming, allowing sequential logic without cumbersome workarounds.
• It could still support parameters, so blocking scripts remain flexible and dynamic.
• Currently, users must manually combine script.execute and script.wait for sequential operations, which is repetitive and error-prone.
• A built-in blocking option would simplify automations, improve readability, and reduce the chance of mistakes in critical sequences (like timed relay activations).

[github-actions[bot]]

🏷️ I've automatically added the component: script label to help categorize this feature request.