git:20260430.fe4436c to git:20260511.e67c66c

---

name: flowstudio-power-automate-build

description: >-

Build, scaffold, and deploy Power Automate cloud flows using the FlowStudio

MCP server. Your agent constructs flow definitions, wires connections, deploys,

and tests — all via MCP without opening the portal.

Load this skill when asked to: create a flow, build a new flow,

deploy a flow definition, scaffold a Power Automate workflow, construct a flow

JSON, update an existing flow's actions, patch a flow definition, add actions

to a flow, wire up connections, or generate a workflow definition from scratch.

Requires a FlowStudio MCP subscription — see https://mcp.flowstudio.app

---

# Build & Deploy Power Automate Flows with FlowStudio MCP

Step-by-step guide for constructing and deploying Power Automate cloud flows

programmatically through the FlowStudio MCP server.

**Prerequisite**: A FlowStudio MCP server must be reachable with a valid JWT.

Subscribe at https://mcp.flowstudio.app

---

## Source of Truth

> This skill covers response shapes, behavioral notes, and build patterns —

---

## Python Helper

```python

import json, urllib.request

MCP_URL = "https://mcp.flowstudio.app/mcp"

MCP_TOKEN = "<YOUR_JWT_TOKEN>"

def mcp(tool, **kwargs):

payload = json.dumps({"jsonrpc": "2.0", "id": 1, "method": "tools/call",

"params": {"name": tool, "arguments": kwargs}}).encode()

req = urllib.request.Request(MCP_URL, data=payload,

headers={"x-api-key": MCP_TOKEN, "Content-Type": "application/json",

"User-Agent": "FlowStudio-MCP/1.0"})

try:

resp = urllib.request.urlopen(req, timeout=120)

except urllib.error.HTTPError as e:

body = e.read().decode("utf-8", errors="replace")

raise RuntimeError(f"MCP HTTP {e.code}: {body[:200]}") from e

raw = json.loads(resp.read())

if "error" in raw:

raise RuntimeError(f"MCP error: {json.dumps(raw['error'])}")

return json.loads(raw["result"]["content"][0]["text"])

ENV = "<environment-id>" # e.g. Default-xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx

```

---

Always look before you build to avoid duplicates:

```python

matches = [f for f in results["flows"]

if "My New Flow".lower() in f["displayName"].lower()]

if len(matches) > 0:

# Flow exists — modify rather than create

FLOW_ID = matches[0]["id"] # plain UUID from list_live_flows

print(f"Existing flow: {FLOW_ID}")

defn = mcp("get_live_flow", environmentName=ENV, flowName=FLOW_ID)

else:

print("Flow not found — building from scratch")

FLOW_ID = None

```

---

Every connector action needs a `connectionName` that points to a key in the

flow's `connectionReferences` map. That key links to an authenticated connection

in the environment.

> **MANDATORY**: You MUST call `list_live_connections` first — do NOT ask the

> user for connection names or GUIDs. The API returns the exact values you need.

> Only prompt the user if the API confirms that required connections are missing.

```python

conns = mcp("list_live_connections", environmentName=ENV)

active = [c for c in conns["connections"]

if c["statuses"][0]["status"] == "Connected"]

```

### 2b — Determine which connectors the flow needs

### 2c — If connections are missing, guide the user

```python

connectors_needed = ["shared_sharepointonline", "shared_office365"] # adjust per flow

missing = [c for c in connectors_needed if c not in conn_map]

```

### 2d — Build the connectionReferences block

```python

connection_references = {}

for connector in connectors_needed:

"source": "Invoker",

"id": f"/providers/Microsoft.PowerApps/apis/{connector}"

}

```

---

Construct the definition object. See [flow-schema.md](references/flow-schema.md)

for the full schema and these action pattern references for copy-paste templates:

- [action-patterns-core.md](references/action-patterns-core.md) — Variables, control flow, expressions

- [action-patterns-data.md](references/action-patterns-data.md) — Array transforms, HTTP, parsing

- [action-patterns-connectors.md](references/action-patterns-connectors.md) — SharePoint, Outlook, Teams, Approvals

```python

definition = {

"$schema": "https://schema.management.azure.com/providers/Microsoft.Logic/schemas/2016-06-01/workflowdefinition.json#",

"contentVersion": "1.0.0.0",

"triggers": { ... }, # see trigger-types.md / build-patterns.md

"actions": { ... } # see ACTION-PATTERNS-*.md / build-patterns.md

}

```

> See [build-patterns.md](references/build-patterns.md) for complete, ready-to-use

> flow definitions covering Recurrence+SharePoint+Teams, HTTP triggers, and more.

```python

environmentName=ENV,

```python

environmentName=ENV,

```

---

`update_live_flow` handles both creation and updates in a single tool.

### Create a new flow (no existing flow)

Omit `flowName` — the server generates a new GUID and creates via PUT:

```python

result = mcp("update_live_flow",

environmentName=ENV,

# flowName omitted → creates a new flow

definition=definition,

connectionReferences=connection_references,

)

if result.get("error") is not None:

print("Create failed:", result["error"])

else:

# Capture the new flow ID for subsequent steps

FLOW_ID = result["created"]

print(f"✅ Flow created: {FLOW_ID}")

```

### Update an existing flow

Provide `flowName` to PATCH:

```python

result = mcp("update_live_flow",

environmentName=ENV,

flowName=FLOW_ID,

definition=definition,

connectionReferences=connection_references,

)

if result.get("error") is not None:

print("Update failed:", result["error"])

else:

print("Update succeeded:", result)

```

> ⚠️ `update_live_flow` always returns an `error` key.

> `null` (Python `None`) means success — do not treat the presence of the key as failure.

>

### Common deployment errors

| Error message (contains) | Cause | Fix |

|---|---|---|

| `missing from connectionReferences` | An action's `host.connectionName` references a key that doesn't exist in the `connectionReferences` map | Ensure `host.connectionName` uses the **key** from `connectionReferences` (e.g. `shared_teams`), not the raw GUID |

| `ConnectionAuthorizationFailed` / 403 | The connection GUID belongs to another user or is not authorized | Re-run Step 2a and use a connection owned by the current `x-api-key` user |

| `InvalidTemplate` / `InvalidDefinition` | Syntax error in the definition JSON | Check `runAfter` chains, expression syntax, and action type spelling |

| `ConnectionNotConfigured` | A connector action exists but the connection GUID is invalid or expired | Re-check `list_live_connections` for a fresh GUID |

---

```python

check = mcp("get_live_flow", environmentName=ENV, flowName=FLOW_ID)

# Confirm state

print("State:", check["properties"]["state"]) # Should be "Started"

# If state is "Stopped", use set_live_flow_state — NOT update_live_flow

# mcp("set_live_flow_state", environmentName=ENV, flowName=FLOW_ID, state="Started")

# Confirm the action we added is there

acts = check["properties"]["definition"]["actions"]

print("Actions:", list(acts.keys()))

```

---

> **MANDATORY**: Before triggering any test run, **ask the user for confirmation**.

> Running a flow has real side effects — it may send emails, post Teams messages,

> write to SharePoint, start approvals, or call external APIs. Explain what the

> flow will do and wait for explicit approval before calling `trigger_live_flow`

> or `resubmit_live_flow_run`.

### Updated flows (have prior runs) — ANY trigger type

> **Use `resubmit_live_flow_run` first.** It works for EVERY trigger type —

> Recurrence, SharePoint, connector webhooks, Button, and HTTP. It replays

> the original trigger payload. Do NOT ask the user to manually trigger the

> flow or wait for the next scheduled run.

```python

runs = mcp("get_live_flow_runs", environmentName=ENV, flowName=FLOW_ID, top=1)

if runs:

# Works for Recurrence, SharePoint, connector triggers — not just HTTP

result = mcp("resubmit_live_flow_run",

environmentName=ENV, flowName=FLOW_ID, runName=runs[0]["name"])

print(result) # {"resubmitted": true, "triggerName": "..."}

```

### HTTP-triggered flows — custom test payload

Only use `trigger_live_flow` when you need to send a **different** payload

than the original run. For verifying a fix, `resubmit_live_flow_run` is

better because it uses the exact data that caused the failure.

```python

result = mcp("trigger_live_flow",

environmentName=ENV, flowName=FLOW_ID,

body={"name": "Test", "value": 1})

print(f"Status: {result['responseStatus']}")

```

### Brand-new non-HTTP flows (Recurrence, connector triggers, etc.)

A brand-new Recurrence or connector-triggered flow has **no prior runs** to

resubmit and no HTTP endpoint to call. This is the ONLY scenario where you

need the temporary HTTP trigger approach below. **Deploy with a temporary

HTTP trigger first, test the actions, then swap to the production trigger.**

```python

production_trigger = definition["triggers"]

definition["triggers"] = {

}

result = mcp("update_live_flow",

environmentName=ENV,

flowName=FLOW_ID, # omit if creating new

definition=definition,

connectionReferences=connection_references,

err = mcp("get_live_flow_run_error",

definition["triggers"] = production_trigger

environmentName=ENV,

flowName=FLOW_ID,

definition=definition,

```

---

## Gotchas

| Mistake | Consequence | Prevention |

|---|---|---|

| Missing `connectionReferences` in deploy | 400 "Supply connectionReferences" | Always call `list_live_connections` first |

| `"operationOptions"` missing on Foreach | Parallel execution, race conditions on writes | Always add `"Sequential"` |

| `union(old_data, new_data)` | Old values override new (first-wins) | Use `union(new_data, old_data)` |

| `split()` on potentially-null string | `InvalidTemplate` crash | Wrap with `coalesce(field, '')` |

| Checking `result["error"]` exists | Always present; true error is `!= null` | Use `result.get("error") is not None` |

| Flow deployed but state is "Stopped" | Flow won't run on schedule | Call `set_live_flow_state` with `state: "Started"` — do **not** use `update_live_flow` for state changes |

| Teams "Chat with Flow bot" recipient as object | 400 `GraphUserDetailNotFound` | Use plain string with trailing semicolon (see below) |

### Teams `PostMessageToConversation` — Recipient Formats

The `body/recipient` parameter format depends on the `location` value:

| Location | `body/recipient` format | Example |

|---|---|---|

| **Chat with Flow bot** | Plain email string with **trailing semicolon** | `"user@contoso.com;"` |

| **Channel** | Object with `groupId` and `channelId` | `{"groupId": "...", "channelId": "..."}` |

> **Common mistake**: passing `{"to": "user@contoso.com"}` for "Chat with Flow bot"

> returns a 400 `GraphUserDetailNotFound` error. The API expects a plain string.

---

## Reference Files

- [flow-schema.md](references/flow-schema.md) — Full flow definition JSON schema

- [trigger-types.md](references/trigger-types.md) — Trigger type templates

- [action-patterns-core.md](references/action-patterns-core.md) — Variables, control flow, expressions

- [action-patterns-data.md](references/action-patterns-data.md) — Array transforms, HTTP, parsing

- [action-patterns-connectors.md](references/action-patterns-connectors.md) — SharePoint, Outlook, Teams, Approvals

- [build-patterns.md](references/build-patterns.md) — Complete flow definition templates (Recurrence+SP+Teams, HTTP trigger)

## Related Skills