Generated banner for Flowstudio Power Automate MCP
Generated logo for Flowstudio Power Automate MCP

Flowstudio Power Automate MCP

GitHubOfficialFirst committed by ninihen1Distributed by GitHub

  • Skill
  • Tool integration
  • Automation and integrations
  • MIT
  • Low risk

From the author

Foundation skill for Power Automate via FlowStudio MCP — auth setup, the reusable MCP helper (Python + Node.js), tool discovery via `list_skills` / `tool_search`, and oversized-response handling. Load this skill first when connecting an agent to Power Automate. For specialized workflows, load `flowstudio-power-automate-build`, `flowstudio-power-automate-debug`, `flowstudio-power-automate-monitoring` (Pro+), or `flowstudio-power-automate-governance` (Pro+) — each contains the workflow narrative, this skill provides the plumbing they all rely on. Requires a FlowStudio MCP subscription or compatible server — see https://mcp.flowstudio.app
— the description by ninihen1

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

This skill provides the essential plumbing required for an AI agent to communicate with a FlowStudio MCP server. It handles authentication, tool discovery, and response parsing, serving as the base layer for more specialized Power Automate workflow skills. It includes reusable helpers for Python and Node.js to manage JSON-RPC communication and provides guidance on handling large API responses that may exceed context windows.

What it does

  • Establishes secure authentication with the FlowStudio MCP server.
  • Provides reusable helper functions for Python and Node.js to handle MCP tool calls.
  • Enables efficient tool discovery using meta-tools like list_skills and tool_search.
  • Offers strategies for managing and parsing oversized API responses.
  • Provides a standardized framework for building, debugging, and monitoring Power Automate flows.
  • Includes reference documentation for Power Automate action types and connector identification.

When to use it

  • As the first step when setting up an AI agent to interact with Power Automate.
  • When you need to establish a reliable connection to a FlowStudio MCP server.
  • When you need to implement the core request-response logic for MCP tool calls.
  • When you need to discover available tools or bundles before executing specific tasks.
  • When you need to handle large data payloads from Power Automate API responses.

Advantages

  • Provides a consistent, reusable foundation for all Power Automate-related agent tasks.
  • Reduces complexity by abstracting JSON-RPC framing and authentication.
  • Optimizes context usage through targeted tool discovery and response handling.
  • Supports multiple programming environments with native helper implementations.
  • Ensures compatibility with specialized workflow skills for building, debugging, and governance.

Usage examples

“Connect to the FlowStudio MCP server and list available skill bundles.”
The agent executes the list_skills tool and returns the available bundles such as build-flow, debug-flow, and monitor-flow.
“Load the tools required for debugging a failing Power Automate flow.”
The agent uses tool_search with the query skill:debug-flow to load the relevant schema set for investigation.

Install

  1. Download the skill as a ZIP:

    https://mp-staging.autogineer.com/agent-skills/github/flowstudio-power-automate-mcp/download
  2. Unzip it into the cross-client skills folder of your project:

    mkdir -p .agents/skills && unzip flowstudio-power-automate-mcp.zip -d .agents/skills

Documentation by ninihen1

Power Automate via FlowStudio MCP — Foundation

This skill is the plumbing layer. It gives an AI agent a reliable way to talk to a FlowStudio MCP server, discover what tools are available, and handle the responses cleanly. The actual workflow narratives live in four specialized skills that all build on this one.

Real debugging examples: Expression error in child flow | Data entry, not a flow bug | Null value crashes child flow

Requires: A FlowStudio MCP subscription (or compatible Power Automate MCP server). You will need:

  • MCP endpoint: https://mcp.flowstudio.app/mcp (same for all subscribers)

  • API key / JWT token (x-api-key header — NOT Bearer)

  • In ChatGPT or claude.ai there is no key: add https://mcp.flowstudio.app/mcp/oauth as a connector and sign in with Microsoft — see the ChatGPT walkthrough

  • Power Platform environment name (e.g. Default-<tenant-guid>)


Which Skill to Use When

Skills are organized by use-case intent, not by which tools they call. Multiple skills reuse the same underlying tools — pick by what the user is trying to accomplish.

The user wants to…Load this skill
Make or change a flow (build new, modify existing, fix a bug, deploy)flowstudio-power-automate-build
Diagnose why a flow failed (root cause analysis on a failing run)flowstudio-power-automate-debug
See tenant-wide flow health, failure rates, asset inventoryflowstudio-power-automate-monitoring (Pro+)
Tag, audit, classify, score, or offboard flowsflowstudio-power-automate-governance (Pro+)
Just connect, set up auth, write the helper, parse responsesthis skill (foundation)

Same tools, different lenses. flowstudio-power-automate-build and flowstudio-power-automate-debug both call update_live_flow, get_live_flow, and the run-error tools — they differ in direction (forward vs backward) and intent (compose vs diagnose). flowstudio-power-automate-monitoring and flowstudio-power-automate-governance both call the Store tools — they differ in audience (ops vs compliance) and outcome (read health vs write metadata). Don't try to memorize "which tools belong to which skill"; pick the skill by what the user is doing.


Source of Truth

PrioritySourceCovers
1Real API responseAlways trust what the server actually returns
2tool_search / list_skillsAuthoritative tool schemas, parameter names, types, required flags
3SKILL docs & reference filesWorkflow narrative, response shapes, non-obvious behaviors

If documentation disagrees with a real API response, the API wins. Tool schemas in this skill (or any other) may lag the server — call tool_search to confirm the current shape before invoking a tool you haven't used recently.


How Agents Discover Tools

The FlowStudio MCP server (v1.1.5+) exposes two non-billable meta-tools that let an agent load only the tools relevant to the current task. Use these in preference to tools/list (which loads all 30+ schemas at once) or guessing tool names.

Meta-toolWhen to call
list_skillsCold start — see the available bundles (build-flow, create-flow, debug-flow, monitor-flow, discover, governance) and pick one
tool_search with query: "skill:<name>"Load the full schema set for one bundle (e.g. skill:debug-flow)
tool_search with query: "select:tool1,tool2"Load specific tools by name (e.g. when chaining across bundles)
tool_search with query: "<keywords>"Free-text search when the user request is ambiguous (e.g. "cancel run")

The server's tool_search bundles are intentionally narrower than this skill family — they're starter packs of the most-likely-needed tools per intent. A workflow skill (e.g. flowstudio-power-automate-debug) may pull a bundle and then call tool_search again for additional tools as the workflow progresses.

# Cold start — pick a bundle by intent
skills = mcp("list_skills", {})
# [{"name": "debug-flow", "description": "Investigate why a flow is failing...",
#   "tools": ["get_live_flow_runs", "get_live_flow_run_error", ...]}, ...]

# Load schemas for the bundle
debug_tools = mcp("tool_search", {"query": "skill:debug-flow"})

Current common bundles:

BundleUse when
create-flowCreating a brand-new flow; includes environment/connection discovery, connector description, dynamic options, and update_live_flow
build-flowReading or modifying an existing flow definition
debug-flowInvestigating failed runs and action-level inputs/outputs
monitor-flowStarting/stopping, triggering, cancelling, or resubmitting runs
discoverEnumerating environments, flows, and connections
governancePro+ cached-store tagging, maker audit, and metadata updates

All examples in this skill family use Python with urllib.request (stdlib — no pip install needed). Node.js is an equally valid choice: fetch is built-in from Node 18+, JSON handling is native, and async/await maps cleanly onto the request-response pattern of MCP tool calls — making it a natural fit for teams already working in a JavaScript/TypeScript stack.

LanguageVerdictNotes
PythonRecommendedClean JSON handling, no escaping issues, all skill examples use it
Node.js (≥ 18)RecommendedNative fetch + JSON.stringify/JSON.parse; no extra packages
PowerShellAvoid for flow operationsConvertTo-Json -Depth silently truncates nested definitions; quoting and escaping break complex payloads. Acceptable for a quick connectivity smoke-test but not for building or updating flows.
cURL / BashPossible but fragileShell-escaping nested JSON is error-prone; no native JSON parser

TL;DR — use the Core MCP Helper (Python or Node.js) below. Both handle JSON-RPC framing, auth, and response parsing in a single reusable function.


Core MCP Helper (Python)

Use this helper throughout all subsequent operations:

import json, urllib.request

TOKEN = "<YOUR_JWT_TOKEN>"
MCP   = "https://mcp.flowstudio.app/mcp"

def mcp(tool, args, cid=1):
    payload = {"jsonrpc": "2.0", "method": "tools/call", "id": cid,
               "params": {"name": tool, "arguments": args}}
    req = urllib.request.Request(MCP, data=json.dumps(payload).encode(),
        headers={"x-api-key": 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'])}")
    text = raw["result"]["content"][0]["text"]
    return json.loads(text)

Common auth errors:

  • HTTP 401/403 → token is missing, expired, or malformed. Get a fresh JWT from mcp.flowstudio.app.

  • HTTP 400 → malformed JSON-RPC payload. Check Content-Type: application/json and body structure.

  • MCP error: {"code": -32602, ...} → wrong or missing tool arguments. Call tool_search with select:<toolname> to confirm the schema.


Core MCP Helper (Node.js)

Equivalent helper for Node.js 18+ (built-in fetch — no packages required):

const TOKEN = "<YOUR_JWT_TOKEN>";
const MCP   = "https://mcp.flowstudio.app/mcp";

async function mcp(tool, args, cid = 1) {
  const payload = {
    jsonrpc: "2.0",
    method: "tools/call",
    id: cid,
    params: { name: tool, arguments: args },
  };
  const res = await fetch(MCP, {
    method: "POST",
    headers: {
      "x-api-key": TOKEN,
      "Content-Type": "application/json",
      "User-Agent": "FlowStudio-MCP/1.0",
    },
    body: JSON.stringify(payload),
  });
  if (!res.ok) {
    const body = await res.text();
    throw new Error(`MCP HTTP ${res.status}: ${body.slice(0, 200)}`);
  }
  const raw = await res.json();
  if (raw.error) throw new Error(`MCP error: ${JSON.stringify(raw.error)}`);
  return JSON.parse(raw.result.content[0].text);
}

Requires Node.js 18+. For older Node, replace fetch with https.request from the stdlib or install node-fetch.


Verify the Connection

A 3-line smoke test that confirms the token, endpoint, and helper all work:

skills = mcp("list_skills", {})
print(f"Connected — {len(skills)} skill bundles available:",
      [s["name"] for s in skills])

Expected output:

Connected — 6 skill bundles available: ['build-flow', 'create-flow', 'debug-flow', 'monitor-flow', 'discover', 'governance']

If this fails, see the Common auth errors note above. If it succeeds, hand off to the workflow skill matching the user's intent.


Handling Oversized Responses

Some MCP tool responses are large enough to overflow the agent's context window:

ToolTypical sizeCause
describe_live_connector100-600 KBFull Swagger spec for a connector
get_live_dynamic_properties50-500 KBDynamic connector field schemas such as SharePoint list columns
get_live_flow_run_action_outputs (no actionName)50 KB – several MBTop-level action outputs; with an action in a foreach, every repetition can be returned
get_live_flow (large flows)50-500 KBDeeply nested branches
list_live_flows (large tenants)50-200 KBHundreds of flow records
When the harness spills to a file

Agent harnesses (Claude Code, VS Code Copilot, etc.) save oversized responses to a temp file (e.g. tool-results/mcp-flowstudio-describe_live_connector-NNNN.txt) and return the path instead of the inline JSON. The file is double-wrapped — the outer MCP envelope plus the inner JSON-escaped payload:

[{"type":"text","text":"<JSON-escaped payload>"}]

Two parses to reach a usable object:

import json
with open(path) as f:
    raw = json.loads(f.read())
payload = json.loads(raw[0]["text"])
$payload = ((Get-Content $path -Raw | ConvertFrom-Json)[0].text) | ConvertFrom-Json
Rules of thumb
  1. Extract, don't echo. Pull the specific field(s) you need (one operationId, one action's outputs) and discard the rest before reasoning about it.

  2. Always pass actionName to get_live_flow_run_action_outputs. Omitting it fetches all top-level actions. For actions inside a foreach, passing actionName without iterationIndex can return every repetition of that action.

  3. Reuse the spill file within a session. Refetching the same connector swagger costs 30+ seconds and produces another spill — cache the path.

  4. Don't grep the spill file for JSON keys directly. Strings are JSON-escaped inside the file (\"OperationId\":), so a plain grep for "OperationId": will not match. Parse first, then filter.

  5. Summarize tool output to the user. Echo name + state + trigger for flow lists and actionName + status + code for run errors — not raw JSON, unless asked.

# Good — drill into one operation in a connector swagger
conn = mcp("describe_live_connector", {"environmentName": ENV, "connectorName": "shared_sharepointonline"})
op = conn["properties"]["swagger"]["paths"]["/datasets/{dataset}/tables/{table}/items"]["get"]
print(op["operationId"], "—", op.get("summary"))

# Bad — keeping the whole 500 KB swagger in context
print(json.dumps(conn, indent=2))   # don't do this

Auth & Connection Notes

FieldValue
Auth headerx-api-key: <JWT> — not Authorization: Bearer
Token formatPlain JWT — do not strip, alter, or prefix it
TimeoutUse ≥ 120 s for get_live_flow_run_action_outputs (large outputs)
Environment nameDefault-<tenant-guid> (find it via list_live_environments or list_live_flows response)

Reference Files

Files

references/tool-reference.md

FlowStudio MCP — Tool Response Catalog

Response shapes and behavioral notes for the FlowStudio Power Automate MCP server.

For tool names and parameters: Prefer list_skills and tool_search. They return focused, up-to-date schemas without loading every MCP tool at once. Use tools/list only as a low-level fallback when the meta-tools are not available. This document covers what tool schemas do NOT tell you: response shapes and non-obvious behaviors discovered through real usage.


Source of Truth

PrioritySourceCovers
1Real API responseAlways trust what the server actually returns
2list_skills / tool_searchTool names, parameter names, types, required flags
3This documentResponse shapes, behavioral notes, gotchas

If this document disagrees with tool_search, tools/list, or real API behavior, the API wins. Update this document accordingly.


Environment & Tenant Discovery

list_live_environments

Response: direct array of environments.

[
  {
    "id": "Default-26e65220-5561-46ef-9783-ce5f20489241",
    "displayName": "FlowStudio (default)",
    "sku": "Production",
    "location": "australia",
    "state": "Enabled",
    "isDefault": true,
    "isAdmin": true,
    "isMember": true,
    "createdTime": "2023-08-18T00:41:05Z"
  }
]

Use the id value as environmentName in all other tools.

list_store_environments

Same shape as list_live_environments but read from cache (faster).


Connection Discovery

list_live_connections

Response: wrapper object with connections array.

{
  "connections": [
    {
      "id": "shared-office365-9f9d2c8e-55f1-49c9-9f9c-1c45d1fbbdce",
      "displayName": "[email protected]",
      "connectorName": "shared_office365",
      "environment": "Default-26e65220-...",
      "createdBy": "User Name",
      "authenticatedUser": "[email protected]",
      "overallStatus": "Connected",
      "statuses": [{"status": "Connected"}],
      "createdTime": "2024-03-12T21:23:55.206815Z",
      "connectionReferenceTemplate": {
        "connectionName": "shared-office365-9f9d2c8e-55f1-49c9-9f9c-1c45d1fbbdce",
        "source": "Invoker",
        "id": "/providers/Microsoft.PowerApps/apis/shared_office365"
      },
      "hostTemplate": {
        "connectionName": "shared_office365"
      }
    }
  ],
  "totalCount": 56,
  "error": null
}

Key field: id is the connectionName value used in connectionReferences.

Key field: connectorName maps to apiId: "/providers/Microsoft.PowerApps/apis/" + connectorName

Filter by status: prefer overallStatus == "Connected" when present; otherwise check statuses[0].status == "Connected".

environmentName is required — the platform cannot list connections across environments (omitting it answers 400 MissingEnvironmentFilter). Get one from list_live_environments.

Pass search=<connector or account> to narrow output and receive connectionReferenceTemplate plus hostTemplate values that can be copied directly into update_live_flow.

list_store_connections

Same connection data from cache.


Flow Discovery & Listing

list_live_flows

Response: wrapper object with flows array.

{
  "mode": "owner",
  "flows": [
    {
      "id": "0757041a-8ef2-cf74-ef06-06881916f371",
      "displayName": "My Flow",
      "state": "Started",
      "triggerType": "Request",
      "triggerKind": "Http",
      "createdTime": "2023-08-18T01:18:17Z",
      "lastModifiedTime": "2023-08-18T12:47:42Z",
      "owners": "<aad-object-id>",
      "definitionAvailable": true
    }
  ],
  "totalCount": 100,
  "nextLink": null,
  "error": null
}

Access via result["flows"]. id is a plain UUID --- use directly as flowName.

mode indicates the access scope used ("owner" or "admin").

Parameters added in newer server versions:

  • search: filter by display name server-side.

  • mode: owner for flows owned by the MCP identity; admin for all flows visible to an admin account.

  • timeoutSeconds: return partial results with nextLink instead of waiting on very large environments.

  • continuationUrl: pass the previous nextLink to continue the same query.

list_store_flows

Response: direct array (no wrapper).

[
  {
    "id": "3991358a-f603-e49d-b1ed-a9e4f72e2dcb.0757041a-8ef2-cf74-ef06-06881916f371",
    "displayName": "Admin | Sync Template v3 (Solutions)",
    "state": "Started",
    "triggerType": "OpenApiConnectionWebhook",
    "environmentName": "3991358a-f603-e49d-b1ed-a9e4f72e2dcb",
    "runPeriodTotal": 100,
    "createdTime": "2023-08-18T01:18:17Z",
    "lastModifiedTime": "2023-08-18T12:47:42Z"
  }
]

id format: <environmentId>.<flowId> --- split on the first . to extract the flow UUID: flow_id = item["id"].split(".", 1)[1]

get_store_flow

Response: single flow metadata from cache (selected fields).

{
  "id": "<environmentId>.<flowId>",
  "displayName": "My Flow",
  "state": "Started",
  "triggerType": "Recurrence",
  "runPeriodTotal": 100,
  "runPeriodFailRate": 0.1,
  "runPeriodSuccessRate": 0.9,
  "runPeriodFails": 10,
  "runPeriodSuccess": 90,
  "runPeriodDurationAverage": 29410.8,
  "runPeriodDurationMax": 158900.0,
  "runError": "{\"code\": \"EACCES\", ...}",
  "description": "Flow description",
  "tier": "Premium",
  "complexity": "{...}",
  "actions": 42,
  "connections": ["sharepointonline", "office365"],
  "owners": ["[email protected]"],
  "createdBy": "[email protected]"
}

runPeriodDurationAverage / runPeriodDurationMax are in milliseconds (divide by 1000). runError is a JSON string --- parse with json.loads().


Flow Definition (Live API)

get_live_flow

Response: full flow definition from PA API.

{
  "name": "<flow-guid>",
  "properties": {
    "displayName": "My Flow",
    "state": "Started",
    "definition": {
      "triggers": { "..." },
      "actions": { "..." },
      "parameters": { "..." }
    },
    "connectionReferences": { "..." }
  }
}
update_live_flow

Create mode: Omit flowName --- creates a new flow. definition and displayName required.

Update mode: Provide flowName --- PATCHes existing flow.

Response:

{
  "created": false,
  "flowKey": "<environmentId>.<flowId>",
  "updated": ["definition", "connectionReferences"],
  "displayName": "My Flow",
  "state": "Started",
  "definition": { "...full definition..." },
  "error": null
}

error is always present but may be null. Check result.get("error") is not None.

On create: created is the new flow GUID (string). On update: created is false.

Required fields can vary by server version. Use tool_search with select:update_live_flow before creating or patching a flow; if a description is required, include either the new description or the existing one from get_live_flow.

The flow description is part of the workflow definition (definition.description), not a top-level tool argument in current schemas.

add_live_flow_to_solution

Migrates a non-solution flow into a solution. Returns error if already in a solution.

Use this after creating a Copilot Studio Skills-triggered flow that must be discoverable as an agent tool. Pass solutionId for the target solution. If the server supports omitting solutionId, it uses the environment's default solution; prefer an explicit unmanaged solution for production ALM.

This tool changes solution membership only. It does not validate the trigger schema, publish a Copilot Studio agent, or prove that the flow is callable by the agent.


Connector Operation Discovery

describe_live_connector

Describes a connector/API and its operations. Use it before creating connector actions instead of guessing operation JSON.

Common modes:

Call shapeUse
search="send email" without connectorNameSearch operations across connectors
connectorName="shared_sharepointonline"Compact operation catalog for one connector
operationId="GetItems"Expanded schema for one operation
variant="flowbot_chat"Authored example for one operation variant

The operation detail can include:

  • hint: authored guidance from the connector hints table.

  • exampleDefinition: copy-ready action/trigger shape when available.

  • Dynamic metadata with nextTool=get_live_dynamic_options or nextTool=get_live_dynamic_properties.

get_live_dynamic_options

Resolves live dropdown/list options for connector parameters. Use this for IDs selected from lists, such as SharePoint sites/lists, Teams teams/channels, or other x-ms-dynamic-list / x-ms-dynamic-values parameters.

Pass the dynamicMetadata object returned by describe_live_connector, the connection id from list_live_connections, and any already-resolved dependent parameters.

get_live_dynamic_properties

Resolves live schema/field properties for connector parameters. Use this for dynamic field sets such as SharePoint list item columns after the site and list are known.

Useful parameters:

  • parameters: dependent values, for example { "dataset": "<site-url>", "table": "<list-id>" }.

  • propertyName: request one field after inspecting the compact response.

  • includeRaw: include raw connector schema only when needed; it can be large.


Run History & Monitoring

get_live_flow_runs

Response: direct array of runs (newest first).

[{
  "name": "<run-id>",
  "status": "Succeeded|Failed|Running|Cancelled",
  "startTime": "2026-02-25T06:13:38Z",
  "endTime": "2026-02-25T06:14:02Z",
  "triggerName": "Recurrence",
  "error": null
}]

top defaults to 30 and auto-paginates for higher values. Set top: 300 for 24-hour coverage on flows running every 5 minutes.

Run ID field is name (not runName). Use this value as the runName parameter in other tools.

get_live_flow_run_error

Response: structured error breakdown for a failed run.

{
  "runName": "08584296068667933411438594643CU15",
  "failedActions": [
    {
      "actionName": "Apply_to_each_prepare_workers",
      "status": "Failed",
      "error": {"code": "ActionFailed", "message": "An action failed."},
      "code": "ActionFailed",
      "startTime": "2026-02-25T06:13:52Z",
      "endTime": "2026-02-25T06:15:24Z"
    },
    {
      "actionName": "HTTP_find_AD_User_by_Name",
      "status": "Failed",
      "code": "NotSpecified",
      "startTime": "2026-02-25T06:14:01Z",
      "endTime": "2026-02-25T06:14:05Z"
    }
  ],
  "allActions": [
    {"actionName": "Apply_to_each", "status": "Skipped"},
    {"actionName": "Compose_WeekEnd", "status": "Succeeded"},
    {"actionName": "HTTP_find_AD_User_by_Name", "status": "Failed"}
  ]
}

failedActions is ordered outer-to-inner --- the last entry is the root cause. Use failedActions[-1]["actionName"] as the starting point for diagnosis.

get_live_flow_run_action_outputs

Response: array of action detail objects.

[
  {
    "actionName": "Compose_WeekEnd_now",
    "status": "Succeeded",
    "startTime": "2026-02-25T06:13:52Z",
    "endTime": "2026-02-25T06:13:52Z",
    "error": null,
    "inputs": "Mon, 25 Feb 2026 06:13:52 GMT",
    "outputs": "Mon, 25 Feb 2026 06:13:52 GMT"
  }
]

actionName is optional: omit it to return top-level actions in the run. Provide it for a specific action. If that action runs inside a foreach, the tool can return every repetition of that action across iterations; pass iterationIndex to pin to one zero-based iteration.

Outputs can be very large (50 MB+) for bulk-data actions. Use 120s+ timeout.


Run Control

resubmit_live_flow_run

Response: { flowKey, resubmitted: true, runName, triggerName }

cancel_live_flow_run

Cancels a Running flow run.

Do NOT cancel runs waiting for an adaptive card response --- status Running is normal while a Teams card is awaiting user input.


HTTP Trigger Tools

get_live_flow_http_schema

Deprecated. Prefer get_live_flow and inspect the Request trigger's inputs.schema plus any Response actions directly from the definition.

Response keys:

flowKey            - Flow GUID
displayName        - Flow display name
triggerName        - Trigger action name (e.g. "manual")
triggerType        - Trigger type (e.g. "Request")
triggerKind        - Trigger kind (e.g. "Http")
requestMethod      - HTTP method (e.g. "POST")
relativePath       - Relative path configured on the trigger (if any)
requestSchema      - JSON schema the trigger expects as POST body
requestHeaders     - Headers the trigger expects
responseSchemas    - Array of JSON schemas defined on Response action(s)
responseSchemaCount - Number of Response actions that define output schemas

The request body schema is in requestSchema (not triggerSchema).

get_live_flow_trigger_url

Deprecated. Prefer trigger_live_flow when you need to run a flow; it fetches the callback URL internally for HTTP triggers and uses the connector runtime for Button and PowerApps triggers, which have no callback URL.

Returns the signed callback URL for HTTP-triggered flows. Response includes flowKey, triggerName, triggerType, triggerKind, triggerMethod, triggerUrl.

trigger_live_flow

Response keys: flowKey, triggerName, triggerKind, invocation, triggerUrl, requiresAadAuth, authType, responseStatus, responseBody, runName, and warning when a required trigger input was not supplied.

Works for Request triggers (HTTP request, Button, PowerApps) and for scheduled (Recurrence) flows. A scheduled flow runs immediately, like the portal's "Run flow" button, and takes no body — one is refused. Automated connector triggers only fire from their source event and return an error.

HTTP triggers go through the signed callback URL (invocation: callbackUrl). Button and PowerApps triggers have no callback URL; with a body they run through the Power Platform connector runtime (connectorFlowToken or connectorApihubToken), which is the only route that delivers the inputs. With no body they use the cheaper direct run (directRun).

runName is returned only for connector-runtime runs. Otherwise look the run up with get_live_flow_runs.

Power Automate does not enforce a trigger's required list. A missing input still starts the run with a null value; warning names the missing keys and the body shape to retry with.

Browser-extension keys cannot reach the connector runtime, so Button and PowerApps triggers run only with an empty body over that key type. The error lists the alternatives (resubmit a past run, default the inputs inside the flow with coalesce(), or use a standard key).

responseStatus + responseBody contain the flow's Response action output. AAD-authenticated triggers are handled automatically.

Content type: body is sent as application/json, so triggerBody() and the trigger schema see the object you passed. Verified 2026-08-27 on server 1.2.43 against Button, PowerAppV2, and Skills triggers with required schemas.


Flow State Management

set_live_flow_state

Start or stop a Power Automate flow in any environment you have access to. Reads the current state first and only issues the start/stop call if a change is actually needed.

Parameters: environmentName, flowName, state ("Started" | "Stopped") — all required.

Response:

{
  "flowName": "6321ab25-7eb0-42df-b977-e97d34bcb272",
  "environmentName": "Default-26e65220-...",
  "requestedState": "Started",
  "actualState": "Started"
}

Use this tool — not update_live_flow — to start or stop a flow. update_live_flow only changes displayName/definition; the PA API ignores state passed through that endpoint.

set_store_flow_state

Start or stop a flow via the live PA API and persist the updated state back to the Power Clarity cache. Same parameters as set_live_flow_state but requires a Power Clarity workspace.

Response (different shape from set_live_flow_state):

{
  "flowKey": "<environmentId>.<flowId>",
  "requestedState": "Stopped",
  "currentState": "Stopped",
  "flow": { /* full gFlows record, same shape as get_store_flow */ }
}

Prefer set_live_flow_state when you only need to toggle state — it's simpler and has no subscription requirement.

Use set_store_flow_state when you need the cache updated immediately (without waiting for the next daily scan) AND want the full updated governance record back in the same call — useful for workflows that stop a flow and immediately tag or inspect it.


Store Tools --- FlowStudio for Teams Only

get_store_flow_summary

Response: aggregated run statistics.

{
  "totalRuns": 100,
  "failRuns": 10,
  "failRate": 0.1,
  "averageDurationSeconds": 29.4,
  "maxDurationSeconds": 158.9,
  "firstFailRunRemediation": "<hint or null>"
}
get_store_flow_runs

Cached run history for the last N days with duration and remediation hints.

get_store_flow_errors

Cached failed-only runs with failed action names and remediation hints.

get_store_flow_trigger_url

Trigger URL from cache (instant, no PA API call).

update_store_flow

Update governance metadata (description, tags, monitor flag, notification rules, business impact).

list_store_makers / get_store_maker

Maker (citizen developer) discovery and detail.

list_store_power_apps

List all Power Apps canvas apps from the cache.


Behavioral Notes

Non-obvious behaviors discovered through real API usage. These are things tool schemas cannot tell you.

get_live_flow_run_action_outputs
  • actionName is optional: omit to get top-level actions, provide to get one action. For actions inside foreach loops, a named action may return multiple repetitions; use iterationIndex to pin to one iteration.

  • Outputs can be 50 MB+ for bulk-data actions --- always use 120s+ timeout.

update_live_flow
  • Required fields can vary by server version; confirm with tool_search (select:update_live_flow) before create/update. If description is required, preserve the existing description when patching.

  • error key is always present in response --- null means success. Do NOT check if "error" in result; check result.get("error") is not None.

  • On create, created = new flow GUID (string). On update, created = false.

  • Cannot change flow state. Only updates displayName, definition, and connectionReferences. Use set_live_flow_state to start/stop a flow.

trigger_live_flow
  • Works for HTTP, Button, PowerApps, and scheduled (Recurrence) triggers. A scheduled flow runs with no body. Automated connector triggers error.

  • Pass trigger inputs as body. A warning in the result means a required input was missing and the run started with it null.

  • AAD-authenticated triggers are handled automatically (Bearer token attached).

get_live_flow_runs
  • top defaults to 30 with automatic pagination for higher values.

  • Run ID field is name, not runName. Use this value as runName in other tools.

  • Runs are returned newest-first.

Teams PostMessageToConversation (via update_live_flow)
  • "Chat with Flow bot": body/recipient = "[email protected];" (string with trailing semicolon).

  • "Channel": body/recipient = {"groupId": "...", "channelId": "..."} (object).

  • poster: "Flow bot" for Workflows bot identity, "User" for user identity.

list_live_connections
  • environmentName is required; the platform cannot list connections across environments. top is applied after search and the result carries truncated + matchedCount when the cap drops matches.

  • Use search=<connector/account> to get smaller output and paste-ready connectionReferenceTemplate / hostTemplate values.

  • id is the value you need for connectionName in connectionReferences.

  • connectorName maps to apiId: "/providers/Microsoft.PowerApps/apis/" + connectorName.

Requirements and compatibility

Written for: GitHub Copilot

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Needs: Needs an MCP server, Needs an API key, Needs Python, Needs Node.js

Security

What our scanner noticed· Low risk

  • Instructions that use the network

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

First committed by
GitHub avatar of ninihen1ninihen1
Publisher
GitHub (Official)
Distributed by
GitHub
Source
github/awesome-copilot · skills/flowstudio-power-automate-mcp · commit 797337f
Licence
MIT License (redistribution allowed)
  • LICENSE (added by AutoGineer from LICENSE)
  • ATTRIBUTION.md (written by AutoGineer)
Synced
Contributors
ninihen1

AutoGineer is not affiliated with or endorsed by ninihen1 or GitHub.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download flowstudio-power-automate-mcp.zip