feature request: Support RedriveExecution for failed Standard Step Functions executions

[AndreKurait]

Additional version check — 2026-10-08

Still unsupported: the eligible failed Standard execution's redrive returns HTTP 501; its original execution remains failed.

The comparison used an unmodified localstack/localstack-pro:2026.8.1 Linux ARM64 image,
repository digest sha256:4aef81c531684570d7b3cfd2805afa02194c929d52bbeedabb7d4874798b1572.
Vendor packages were localstack-core 2026.8.1, moto-ext 5.1.48, and bundled
boto3/botocore 1.43.78. HTTP probes used a separate boto3/botocore 1.43.101
client; the process-local security-group probe used the bundled interpreter.
The same scripts were used, with no custom extensions or provider source changes.
Owned test containers and the disposable network were removed.
This is a second specifically tested version, not a claim to have tested the latest release.

---

Existing report search

I searched the LocalStack issue tracker and current organization Discussions for this operation and failure. I did not find an existing report for this exact reproduction.

Current behavior

RedriveExecution returns HTTP 501 InternalFailure, with a message stating that the operation is not implemented.

The public API reproducer creates a Standard workflow containing a single Fail state, runs it to its intentional failure, and immediately requests redrive. The execution is only seconds old and has three history events, so execution age and history-size limits do not explain the refusal. The rejected request leaves the original execution FAILED.

This was reproduced on a fresh, unmodified LocalStack container. I am filing it as a missing capability, rather than treating an intentional Fail state as an execution-engine bug.

Expected behavior

Accept redrive for this eligible execution, return redriveDate, preserve the original execution ARN/input/history, and append an ExecutionRedriven event. Reentering the same Fail state should fail again; that second failure is the correct outcome.

References: RedriveExecution API and redrive behavior by state.

Starting a new execution from the beginning is not equivalent: it changes the execution identity and repeats completed work. Eligibility checks, client-token idempotence, and history preservation are part of the requested behavior.

Environment

• Tested on 2026-10-07, Linux, using localstack/localstack-pro:2026.7.5.
• Repository digest: sha256:0d74e1d2d7ce13a3cb25fc64cf15eb225f1c95c762e56e057bc6a9ed0ed29306.
• Vendor-installed distributions: localstack-core 2026.7.5, moto-ext 5.1.46, moto.__version__ = 5.1.21.dev, boto3/botocore 1.43.51.
• Fresh disposable container, no application code, no custom extensions, no source patches.
• This is an affected-version report, not a claim that the latest LocalStack release or standalone Moto still has the defect.

Fresh confirmation on 2026-10-08: the same discrepancy reproduced on Linux ARM64 against the same unmodified image, using a separate boto3/botocore 1.43.101 client. The disposable container and network were removed after the run. The startup block below includes the run's disabled DNS listener/default EC2-image downloads and temporary state storage; no provider source or extension was changed.

Steps to reproduce

Start a disposable instance on a free loopback port:

# LOCALSTACK_AUTH_TOKEN is read from your environment, never embedded in this report.
set -eu
container=$(docker run --rm -d \
  -p 127.0.0.1:4567:4566 -e LOCALSTACK_AUTH_TOKEN \
  -e DNS_ADDRESS=0 -e EC2_DOWNLOAD_DEFAULT_IMAGES=0 \
  --tmpfs /var/lib/localstack \
  localstack/localstack-pro:2026.7.5)
trap 'docker stop "$container" >/dev/null' EXIT
ready=false
for attempt in $(seq 1 60); do
  if curl --fail --silent http://127.0.0.1:4567/_localstack/health >/dev/null; then
    ready=true
    break
  fi
  sleep 1
done
"$ready"
python stepfunctions_redrive_execution.py --endpoint-url http://127.0.0.1:4567

Run the block in a disposable shell. Port 4567 must be free. The client needs boto3; it uses only dummy credentials and a loopback endpoint. It creates disposable resources and cleans them up in finally; the shell trap removes the container even when the script reports failure. A nonzero exit is expected while the reported discrepancy is present. No Docker socket mount or application services are required.

Complete standalone reproducer: stepfunctions_redrive_execution.py

"""Check RedriveExecution for an eligible failed Standard workflow locally."""
import argparse
import json
import time
import uuid
from urllib.parse import urlsplit

import boto3
from botocore.config import Config
from botocore.exceptions import ClientError


def wait_terminal(states, execution):
    deadline = time.monotonic() + 15
    while True:
        result = states.describe_execution(executionArn=execution)
        if result["status"] != "RUNNING":
            return result
        if time.monotonic() >= deadline:
            raise AssertionError("Disposable workflow did not finish within 15 seconds")
        time.sleep(0.1)


def run(endpoint):
    if urlsplit(endpoint).hostname not in {"localhost", "127.0.0.1", "::1"}:
        raise ValueError("This reproducer accepts only a loopback endpoint")
    options = {
        "endpoint_url": endpoint, "region_name": "us-east-1",
        "aws_access_key_id": "test", "aws_secret_access_key": "test",
        "config": Config(proxies={}, retries={"max_attempts": 0}),
    }
    states, iam = boto3.client("stepfunctions", **options), boto3.client("iam", **options)
    name = "redrive-repro-" + uuid.uuid4().hex[:12]
    machine, execution = None, None
    role = iam.create_role(
        RoleName=name,
        AssumeRolePolicyDocument=json.dumps({
            "Version": "2012-10-17", "Statement": [{
                "Effect": "Allow", "Principal": {"Service": "states.amazonaws.com"},
                "Action": "sts:AssumeRole",
            }],
        }),
    )["Role"]["Arn"]
    try:
        machine = states.create_state_machine(
            name=name, roleArn=role, type="STANDARD",
            definition=json.dumps({
                "StartAt": "Fail", "States": {
                    "Fail": {"Type": "Fail", "Error": "ReproFailure", "Cause": "intentional failure"},
                },
            }),
        )["stateMachineArn"]
        execution = states.start_execution(
            stateMachineArn=machine, input=json.dumps({"retained": "original input"}),
        )["executionArn"]
        before = wait_terminal(states, execution)
        assert before["status"] == "FAILED" and before["error"] == "ReproFailure", before
        prior_events = states.get_execution_history(executionArn=execution)["events"]
        assert len(prior_events) < 24999
        try:
            response = states.redrive_execution(executionArn=execution, clientToken=uuid.uuid4().hex)
        except ClientError as error:
            after = states.describe_execution(executionArn=execution)
            print(json.dumps({
                "initial_status": before["status"], "initial_error": before["error"],
                "initial_history_events": len(prior_events),
                "redrive_http_status": error.response["ResponseMetadata"]["HTTPStatusCode"],
                "redrive_error": error.response["Error"],
                "status_after_rejected_redrive": after["status"],
            }, indent=2), flush=True)
            raise AssertionError("An eligible Standard execution was not redriven") from error
        after = wait_terminal(states, execution)
        events = states.get_execution_history(executionArn=execution)["events"]
        report = {
            "redrive_date_present": "redriveDate" in response,
            "status_after_redrive": after["status"],
            "error_after_redrive": after.get("error"),
            "same_execution_and_input": (
                after["executionArn"] == execution and after["input"] == before["input"]
            ),
            "original_history_preserved": events[:len(prior_events)] == prior_events,
            "redrive_events": sum(event["type"] == "ExecutionRedriven" for event in events),
        }
        print(json.dumps(report, indent=2), flush=True)
        assert report["redrive_date_present"] and report["same_execution_and_input"], report
        assert report["original_history_preserved"] and report["redrive_events"] == 1, report
        # Redrive reenters the Fail state; failure again is the correct outcome.
        assert after["status"] == "FAILED" and after["error"] == "ReproFailure", report
    finally:
        if execution is not None:
            if states.describe_execution(executionArn=execution)["status"] == "RUNNING":
                states.stop_execution(executionArn=execution, error="ReproducerCleanup")
        if machine is not None:
            states.delete_state_machine(stateMachineArn=machine)
        iam.delete_role(RoleName=name)
        print(json.dumps({"cleanup": "Owned state machine and role deleted"}), flush=True)


if __name__ == "__main__":
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--endpoint-url", default="http://127.0.0.1:4566")
    run(parser.parse_args().endpoint_url)

[ryan-berke]

Hi @AndreKurait, thanks for raising this. I have filed this in our internal tracker, so when this gets picked up we will make sure to notify you. I don't have an immediate ETA to share at the moment, but rest assured we will implement support for RedriveExecution in the future.

Thanks again for the request!