Fix: Python Approval Step In Windmill Not Receiving Payload

Understanding the Windmill Approval Step Bug

The core issue: The Python approval step within the Windmill workflow is failing to correctly receive the payload when resuming after an approval request. This is in contrast to the TypeScript implementation, which functions as expected. Specifically, the Python function doesn't recognize the approved parameter passed via a curl command to the resume URL, resulting in an empty or null value for approved on the resumed run. This behavior prevents the workflow from correctly determining whether the approval was granted or denied, thus disrupting the intended flow. When dealing with workflow automation, understanding this bug is critical, because it affects the fundamental function of the approval steps.

To put it in more detail, Imagine a scenario: a user triggers a workflow within Windmill, where a Python script serves as an approval gate. The script, when first executed, correctly provides URLs for approving or canceling the request. However, after the user interacts, sending a "yes" payload, the Python script is expected to receive this response. But, the bug prevents this. Instead, the script acts as if it's the first run, leading to unexpected behavior. This affects the user's ability to control the workflow, and the automation is unable to properly adapt to external decisions. This leads to broken automation, resulting in a loss of automation value. Troubleshooting this requires examining the function's parameter handling, the resumption mechanism, and the way payloads are sent and received in this process.

Let's consider how this compares with its TypeScript counterpart. The TypeScript implementation of a similar approval step correctly receives and processes the approved parameter. This difference highlights a discrepancy in how Python and TypeScript handle the resumption of workflows in Windmill, pointing to a potential issue within the Python runtime or the way it integrates with Windmill's workflow engine.

Reproducing the Bug: Step-by-Step Guide

Replicating the problem is straightforward, and the following steps will help you confirm the bug and verify the issue in your environment. Here's how to reproduce the bug within your Windmill environment using the provided code snippets and curl commands. This will enable you to experience the problem firsthand.

Step 1: Python Approval Step Setup

Start by creating a Python approval step in your Windmill workflow. Use the Python code block provided in the original bug report. Make sure to define a function that handles the initial execution and the resumption process. The Python function is supposed to receive an approved argument. In the initial run, when there's no approval status, the script provides approve_url and cancel_url. After the user interacts, the same function should be re-executed with the approved parameter. This is where the bug manifests itself, as the approved parameter is not correctly received.

import wmill

def main(approved: str | None = None):
    # First run, no approved status known
    if not approved:
        urls = wmill.get_resume_urls()
        approve_url = f"{urls['resume']}"
        cancel_url = f"{urls['cancel']}"
        return {
            "approve_url": approve_url,
            "cancel_url": cancel_url,
            "decision": "pending",
            "approved": None
        }

    # Tweede run, beslissing ontvangen
    is_yes = str(approved).lower() == "yes"
    return {
        "approved": is_yes,
        "decision": "approved" if is_yes else "rejected"
    }

Step 2: Testing the Approval with curl

After setting up the Python approval step, the next step involves testing the approval mechanism using curl. This allows you to simulate a user's approval or rejection action.

1. Obtain the Resume URL: After initiating the workflow containing the Python approval step, retrieve the resume URL. This URL is crucial because it allows you to simulate the resumption of the workflow after an approval decision. When the script returns the pending status, it should also provide a resume URL. Copy this URL, because it is necessary to proceed to the next step.
2. Send the Approval Payload: Use the curl command provided in the bug report to send a POST request to the resume URL. Include a JSON payload with an "approved": "yes" value to simulate an approval. This step imitates the approval action.

curl -X POST '<windmill_resume_url>' \
  -H 'Content-Type: application/json' \
  -d '{"approved": "yes"}'

Step 3: Observe the Unexpected Behavior

Following the curl command, observe the output or behavior of the Python script. The expected outcome is for the script to recognize the approval and return {"approved": true, "decision": "approved"}. However, due to the bug, the script will likely behave as if it's the first run, failing to recognize the approved parameter, or the parameter will be null or empty, resulting in the script's logic not being executed as intended, indicating that the payload is not correctly received by the Python script, confirming the bug.

Analyzing the Code and Pinpointing the Root Cause

To understand the underlying cause of the bug, the Python code and its interaction with the Windmill environment need a closer examination. Code review and debugging: Focus on how the Python function is receiving and processing the approved parameter. The first thing to consider is the function signature. Make sure that the approved parameter is correctly defined as str | None = None. This means it can accept either a string or None, which is crucial for handling the initial and resumed states of the workflow. If it's not correctly defined, it won't receive the payload from the approval step.

The wmill.get_resume_urls() call is essential, it fetches the URLs for resuming and canceling the workflow. Confirm that these URLs are correctly constructed and accessible. These URLs are the communication channels for the approval process. The construction of the resume URL itself needs examination. Is there any discrepancy in how the URL is created and how the payload is sent? The curl command sends the approval as a JSON payload, so the Python script needs to be correctly configured to receive and parse the JSON. If the Python script is not configured to parse the JSON correctly, or if there's an issue with the content type header, the script may fail to read the data. In addition, the way Windmill handles the resumption of Python functions, and how it passes parameters during this process, is also very important.

By comparing the correct TypeScript implementation, you can gain insights. TypeScript and Python may handle parameters, especially optional ones, differently. See how the TypeScript code receives the approved parameter; this will help determine if it's a difference in how these languages handle this part of the process or if there is a problem with the Windmill runtime itself. Further investigation should involve logging within the Python function to print the value of the approved parameter at various stages. This will immediately show whether the parameter is correctly received or if there's a problem during the resumption.

Potential Workarounds and Solutions

While a definitive fix may require changes to the Windmill platform, there are potential workarounds to help mitigate the impact of the bug:

1. Parameter Passing: Explore alternative methods for passing the approved parameter. Instead of relying on a JSON body, you might try encoding the decision in the resume URL as a query parameter (e.g., ?approved=yes). This workaround can bypass the issue with how the payload is processed.
2. Data Serialization: Before passing the data, serialize the data so that it is properly formatted to be received by the function. You can serialize your data to ensure that the parameter is correctly passed when resuming. Ensure the format matches what the Python function expects.
3. Intermediate Step: Introduce an intermediate step within the Windmill workflow to process the approval decision and then pass it to the Python function. This intermediate step can receive the approval payload and prepare the data for the Python function, as well as handle any necessary format conversions.
4. Version Check: Validate the version of Windmill being used. Bugs and issues are sometimes resolved in subsequent releases. If you haven't updated, try updating to the latest version.

To correct the core problem, developers should concentrate on two primary areas:

• Parameter Handling: Validate how the Python function receives and processes the approved parameter. This will ensure that the Windmill platform correctly transmits the data.
• Resume Mechanism: Understand how Windmill resumes Python functions and the mechanism for passing parameters during the resumption process. This requires looking into the Windmill framework to understand how these elements function within the system.

Conclusion: Navigating the Python Approval Step Bug

In conclusion, the bug in the Python approval step within Windmill significantly impacts workflow automation, preventing the correct reception of the approval payload. By thoroughly testing and understanding the problem, identifying the code's root causes, and implementing effective workarounds, users can successfully navigate this challenge. While waiting for a comprehensive fix, the provided solutions can help maintain the integrity and reliability of approval processes within the Windmill environment. This problem emphasizes the value of rigorous testing, meticulous debugging, and creative solutions in modern software development.

For more detailed information on Windmill and workflow management, consider visiting the official Windmill Labs documentation .