README.md

---
license: mit
tags:
  - openenv
  - reinforcement-learning
  - agentic-ai
  - debugging
  - power-automate
  - automation
  - llm
library_name: openenv
task_categories:
  - reinforcement-learning
  - reasoning
  - debugging
datasets:
  - custom
metrics:
  - success-rate
language:
  - en
pretty_name: OpenEnv Flow Debugger
---


# OpenEnv Flow Debugger  
*A real-world agentic debugging environment for Power Automate*

This project is a small, easy-to-use debugging tool built with OpenEnv. It's inspired by those tricky real-world problems we hit in tools like Power Automate.

Our environment focuses on a super common issue: those annoying '400 BadRequest' errors that pop up when a condition in your automation flow has a syntax mistake.

The main idea here isn't to build a perfect smart agent right away. Instead, we want to create a clear, realistic, and expandable way to test and improve how agents fix bugs.

---

## What You Need to Do

Imagine you have a Power Automate Flow that just failed.

It failed because of an "HTTP 400 BadRequest" error.
This error happened in a "Condition" step.
And the condition expression has a tiny syntax error.

Your job as the agent is to fix that broken condition expression so the flow can run perfectly.

Each time you play (each "episode"), it's like facing a real-life debugging puzzle that automation engineers deal with all the time.

---

## What You See (Observation Space)

At each step, you'll get some info in a JSON-like format. It includes:

-   `case_id`: A unique ID for this specific problem.
-   `run_status`: Tells you if the flow is still 'Failed' or 'Succeeded'.
-   `failed_step`: Which step caused the problem.
-   `error`: Details about the error, like the code and a message.
-   `steps`: A list of all the steps in the flow, showing their inputs and outputs.
-   `attempts_left`: How many more tries you have to fix it.

**Example observation (kept simple):**

```
case_id: CASE_001
run_status: Failed
failed_step: Condition_Check
error: code=400, message=BadRequest, details=InvalidTemplate: The expression is invalid
steps:
- Compose_Ext (Succeeded, outputs: xlsx)
- Condition_Check (Failed, expression: @equals(outputs('Compose_Ext'),'xlsx')
attempts_left: 3
```

---

## What You Can Do (Action Space - Just Starting!)

Right now, in this simple version, you can only do one type of action.

You can submit a `patch_step` action. This action targets the `Condition_Check` step and updates its `inputs.expression` field.

**Example action:**

```
action = patch_step
step = Condition_Check
field = inputs.expression
value = @equals(outputs('Compose_Ext'),'xlsx')
```

For now, your fix needs to be an *exact* match to what's expected for it to count as correct.

---

## How You Get Graded (Reward Function)

Our scoring system is pretty straightforward:

-   **+1.0** if you successfully fix the flow.
-   **-0.1** for trying an incorrect fix (but you still have tries left).
-   **-0.2** if you run out of tries without fixing it.

The game (episode) ends when the flow is fixed, or when you run out of chances.

---

## The Problems (Dataset)

The specific bugs we're trying to fix are stored in JSON files here:

`flow_debugger_env/data/cases.json`

Each problem includes the messed-up flow state, error details, and a hidden 'gold_fix' (the right answer) that the environment uses to check your work. You, the agent, never see this 'gold_fix'.

---

## How to Run the Example

Just run the `demo.py` file from the main project folder like this:

`python demo.py`

The demo will pick a random bug, use a basic rule-based agent to try and fix the condition expression, and then show you how it went.

---

## What This Can't Do Yet (Limitations)

This simple version is kept small on purpose:

-   It only deals with syntax errors in Condition expressions.
-   It doesn't actually run real Power Automate flows.
-   It doesn't connect to any outside services or APIs.
-   It's not doing fancy AI learning (like reinforcement learning) yet.

Keeping things simple means it's fast, predictable, and easy for us to build on later.

---

## What's Next?

We could add more cool stuff later, like:

-   Figuring out errors in 'filter array' settings.
-   Dealing with 'null' values or wrong data types.
-   Fixing multiple steps at once.
-   Using smarter, AI-powered agents.
-   Training AI using special tools like TRL or Unsloth.
-   Adding 'Green Agent' wrappers.

---

## Why We Made This

Debugging Power Automate is a real headache for many, and it's a big deal. This environment turns those everyday automation failures into a structured task for agents and a useful testbed for learning and experimenting with OpenEnv.