powerautomate-mcp 0.7.9 → 0.9.0

package/dist/index.js

@@ -1134,6 +1134,28 @@ async function createAuthProviderFromConfig(clientId, tenantId, cachePath, silen
   };
   return createWamAuthProvider(config, silentOnly);
 }
+
+// src/utils/jwt-claims.ts
+function decodeJwtClaims(token) {
+  try {
+    const parts = token.split(".");
+    if (parts.length < 2 || !parts[1]) return {};
+    const padded = parts[1].replace(/-/g, "+").replace(/_/g, "/");
+    const padding = padded.length % 4 === 0 ? "" : "=".repeat(4 - padded.length % 4);
+    const json = Buffer.from(padded + padding, "base64").toString("utf-8");
+    const claims = JSON.parse(json);
+    return claims && typeof claims === "object" ? claims : {};
+  } catch {
+    return {};
+  }
+}
+function getOidFromToken(token) {
+  const claims = decodeJwtClaims(token);
+  const oid = claims.oid;
+  return typeof oid === "string" && oid.length > 0 ? oid : void 0;
+}
+
+// src/api/flow-management.ts
 var apiLogger = createChildLogger({ module: "flow-api" });
 var FlowManagementApi = class {
   authProvider;
@@ -1142,6 +1164,18 @@ var FlowManagementApi = class {
     this.authProvider = config.authProvider;
     this.defaultEnvironmentId = config.defaultEnvironmentId;
   }
+  /**
+   * Return the current user's Azure AD object ID derived from the access token.
+   * Used for client-side ownership filtering. Returns undefined if extraction fails.
+   */
+  async getCurrentUserOid() {
+    try {
+      const token = await this.authProvider.getToken();
+      return getOidFromToken(token);
+    } catch {
+      return void 0;
+    }
+  }
   /**
    * Get authorization header with bearer token
    */
@@ -1484,6 +1518,30 @@ var FlowManagementApi = class {
       return data;
     }, "Fetch resource link");
   }
+  async getFlowRunActionRepetitions(flowId, runId, actionName, environmentId) {
+    const envId = environmentId ?? this.defaultEnvironmentId;
+    const safeFlowId = validateRowId(flowId);
+    const safeRunId = validateFlowRunId(runId);
+    const safeActionName = encodeURIComponent(actionName);
+    apiLogger.debug({ flowId: safeFlowId, runId: safeRunId, actionName }, "Getting action repetitions");
+    const url = this.buildUrl(
+      envId,
+      `/flows/${safeFlowId}/runs/${safeRunId}/actions/${safeActionName}/repetitions`
+    );
+    const headers = await this.getAuthHeaders();
+    return wrapApiCall(async () => {
+      const response = await request(url, { method: "GET", headers });
+      const data = await this.handleResponse(
+        response,
+        `Get repetitions for action ${actionName}`
+      );
+      apiLogger.info(
+        { flowId, runId, actionName, count: data.value.length },
+        "Retrieved action repetitions"
+      );
+      return data.value;
+    }, `Get repetitions for action ${actionName}`);
+  }
   // ==========================================================================
   // Flow Sharing & Permissions
   // ==========================================================================
@@ -4212,11 +4270,15 @@ var listFlowsInputSchema = z.object({
   environment: z.string().optional().describe("Environment name or GUID. Uses default if omitted."),
   search: z.string().optional().describe("Search flows by display name (case-insensitive substring match). Applied client-side after fetching."),
   filter: z.string().optional().describe(`OData filter expression (e.g., "properties/state eq 'Started'")`),
-  top: z.number().min(1).max(250).optional().describe("Maximum number of results to return (default 50, max 250)")
+  top: z.number().min(1).max(250).optional().describe("Maximum number of results to return (default 50, max 250)"),
+  scope: z.enum(["owned", "shared", "all"]).optional().default("all").describe(
+    "Filter by ownership: 'owned' = only flows you created, 'shared' = only flows shared with you, 'all' = both (default)."
+  ),
+  includeOwner: z.boolean().optional().default(true).describe("Include owner/creator name in the output (default true).")
 });
 var listFlowsTool = {
   name: "list_flows",
-  description: "List Power Automate flows in an environment. Returns flow names, IDs, state (Started/Stopped), and last modified dates. Use this to discover what flows exist before getting details or making changes.",
+  description: "List Power Automate flows in an environment. Returns flow names, IDs, state (Started/Stopped), last modified dates, and owners. Use scope='shared' to find flows shared with you, scope='owned' for your flows only. Use this to discover what flows exist before getting details or making changes.",
   inputSchema: {
     type: "object",
     properties: {
@@ -4237,6 +4299,17 @@ var listFlowsTool = {
         description: "Maximum number of results to return (default 50, max 250)",
         minimum: 1,
         maximum: 250
+      },
+      scope: {
+        type: "string",
+        enum: ["owned", "shared", "all"],
+        description: "Filter by ownership: 'owned' = only flows you created, 'shared' = only flows shared with you, 'all' = both (default).",
+        default: "all"
+      },
+      includeOwner: {
+        type: "boolean",
+        description: "Include owner/creator name in the output (default true).",
+        default: true
       }
     }
   }
@@ -4262,14 +4335,39 @@ async function handleListFlows(api, input) {
     const needle = parsed.search.toLowerCase();
     flows = flows.filter((f) => f.properties.displayName.toLowerCase().includes(needle));
   }
+  let currentUserOid;
+  if (parsed.scope !== "all" || parsed.includeOwner) {
+    currentUserOid = await api.getCurrentUserOid();
+    if (parsed.scope !== "all" && !currentUserOid) {
+      logger.warn("list_flows: could not derive current user OID; scope filter will not apply");
+    }
+  }
+  if (parsed.scope !== "all" && currentUserOid) {
+    flows = flows.filter((f) => {
+      const creatorId = f.properties.creator?.id;
+      if (!creatorId) return false;
+      const isOwned = creatorId === currentUserOid;
+      return parsed.scope === "owned" ? isOwned : !isOwned;
+    });
+  }
   if (flows.length === 0) {
-    return "No flows found";
+    return parsed.scope === "shared" ? "No flows shared with you in this environment." : parsed.scope === "owned" ? "No flows you own in this environment." : "No flows found";
   }
-  const lines = [`Flows (${flows.length}):`];
+  const scopeLabel = parsed.scope === "owned" ? "Owned" : parsed.scope === "shared" ? "Shared with you" : "Flows";
+  const lines = [`${scopeLabel} (${flows.length}):`];
   for (const flow of flows) {
     const state = flow.properties.state === "Started" ? "\u25B6" : "\u23F9";
     const modified = new Date(flow.properties.lastModifiedTime).toLocaleDateString();
-    lines.push(`  ${state} ${flow.properties.displayName} (${flow.name}) - ${modified}`);
+    let line = `  ${state} ${flow.properties.displayName} (${flow.name}) - ${modified}`;
+    if (parsed.includeOwner) {
+      const creator = flow.properties.creator;
+      const ownerName = creator?.displayName ?? creator?.email;
+      const isOwnedTag = currentUserOid && creator?.id === currentUserOid ? " [owned]" : creator ? " [shared]" : "";
+      if (ownerName) {
+        line += ` \u2014 ${ownerName}${isOwnedTag}`;
+      }
+    }
+    lines.push(line);
   }
   if (result.nextLink) {
     lines.push(`
@@ -4280,11 +4378,14 @@ async function handleListFlows(api, input) {
 var getFlowInputSchema = z.object({
   flowId: z.string().describe("The flow ID (GUID) to retrieve"),
   environment: z.string().optional().describe("Environment name or GUID. Uses default if omitted."),
-  includeDefinition: z.boolean().optional().default(true).describe("Include the full flow definition JSON (default true)")
+  includeDefinition: z.boolean().optional().default(true).describe("Include the full flow definition JSON (default true)"),
+  format: z.enum(["summary", "json", "both"]).optional().default("summary").describe(
+    "Output format: 'summary' = human-readable top-level overview (default), 'json' = full raw flow.properties.definition with all nested actions, 'both' = summary followed by full JSON. Use 'json' or 'both' to capture nested actions inside Switch/If/Foreach/Scope."
+  )
 });
 var getFlowTool = {
   name: "get_flow",
-  description: "Get the complete definition of a Power Automate flow including triggers, actions, and connection references. Use list_flows first to find flow IDs.",
+  description: "Get the complete definition of a Power Automate flow including triggers, actions, connection references, and description. Use list_flows first to find flow IDs. Set format='json' or format='both' to capture the FULL definition including nested actions inside Switch/If/Foreach/Scope (the default 'summary' format only shows top-level actions).",
   inputSchema: {
     type: "object",
     properties: {
@@ -4300,6 +4401,12 @@ var getFlowTool = {
         type: "boolean",
         description: "Include the full flow definition JSON (default true)",
         default: true
+      },
+      format: {
+        type: "string",
+        enum: ["summary", "json", "both"],
+        description: "Output format: 'summary' = top-level overview (default), 'json' = full raw definition with all nested actions, 'both' = summary plus full JSON.",
+        default: "summary"
       }
     },
     required: ["flowId"]
@@ -4307,7 +4414,7 @@ var getFlowTool = {
 };
 async function handleGetFlow(api, input) {
   const parsed = getFlowInputSchema.parse(input);
-  logger.info({ flowId: parsed.flowId }, "Executing get_flow");
+  logger.info({ flowId: parsed.flowId, format: parsed.format }, "Executing get_flow");
   const flow = await api.getFlow(parsed.flowId, parsed.environment);
   const triggers = flow.properties.definition.triggers;
   const actions = flow.properties.definition.actions;
@@ -4320,6 +4427,22 @@ async function handleGetFlow(api, input) {
       tier: ref.tier
     })
   );
+  const description = flow.properties.description;
+  const creator = flow.properties.creator;
+  if (parsed.format === "json") {
+    const payload = {
+      id: flow.name,
+      displayName: flow.properties.displayName,
+      description,
+      state: flow.properties.state,
+      createdTime: flow.properties.createdTime,
+      lastModifiedTime: flow.properties.lastModifiedTime,
+      creator,
+      connectionReferences: flow.properties.connectionReferences,
+      definition: flow.properties.definition
+    };
+    return JSON.stringify(payload, null, 2);
+  }
   const lines = [
     `## ${flow.properties.displayName}`,
     ``,
@@ -4329,6 +4452,12 @@ async function handleGetFlow(api, input) {
     `**Actions:** ${Object.keys(actions).length}`,
     `**Modified:** ${new Date(flow.properties.lastModifiedTime).toLocaleDateString()}`
   ];
+  if (description) {
+    lines.push(`**Description:** ${description}`);
+  }
+  if (creator?.displayName || creator?.email) {
+    lines.push(`**Owner:** ${creator.displayName ?? creator.email}${creator.id ? ` (${creator.id})` : ""}`);
+  }
   if (connectionRefs.length > 0) {
     lines.push(``, `### Connections`);
     for (const conn of connectionRefs) {
@@ -4337,7 +4466,7 @@ async function handleGetFlow(api, input) {
     }
   }
   if (parsed.includeDefinition !== false) {
-    lines.push(``, `### Actions`);
+    lines.push(``, `### Actions (top-level)`);
     for (const [name, action] of Object.entries(actions)) {
       const act = action;
       const deps = act.runAfter ? Object.keys(act.runAfter).join(", ") : "trigger";
@@ -4346,6 +4475,11 @@ async function handleGetFlow(api, input) {
         lines.push(`  inputs: ${JSON.stringify(act.inputs, null, 2).split("\n").join("\n  ")}`);
       }
     }
+    lines.push(``);
+    lines.push(`_Note: Nested actions inside Switch/If/Foreach/Scope are not expanded in this view. Call get_flow with format="json" or format="both" to capture them._`);
+  }
+  if (parsed.format === "both") {
+    lines.push(``, `### Full Definition (JSON)`, "```json", JSON.stringify(flow.properties.definition, null, 2), "```");
   }
   return lines.join("\n");
 }
@@ -5802,6 +5936,7 @@ var connectionRefSchema = z.object({
 });
 var createFlowInputSchema = z.object({
   displayName: z.string().describe("The display name for the new flow"),
+  description: z.string().optional().describe("Optional description for the flow"),
   trigger: triggerSchema.describe("The trigger definition"),
   triggerName: z.string().optional().default("manual").describe("Name for the trigger (default: 'manual')"),
   actions: z.record(actionSchema).describe("Actions in the flow, keyed by action name"),
@@ -5819,6 +5954,10 @@ var createFlowTool = {
         type: "string",
         description: "The display name for the new flow"
       },
+      description: {
+        type: "string",
+        description: "Optional description shown in the Power Automate UI"
+      },
       trigger: {
         type: "object",
         description: "The trigger definition with type, kind, inputs, and optional recurrence",
@@ -5946,7 +6085,8 @@ async function handleCreateFlow(api, input) {
     properties: {
       displayName: parsed.displayName,
       definition,
-      connectionReferences: Object.keys(connectionReferences).length > 0 ? connectionReferences : void 0
+      connectionReferences: Object.keys(connectionReferences).length > 0 ? connectionReferences : void 0,
+      ...parsed.description !== void 0 ? { description: parsed.description } : {}
     }
   };
   try {
@@ -6008,16 +6148,25 @@ var connectionRefSchema2 = z.object({
 var updateFlowInputSchema = z.object({
   flowId: z.string().describe("The flow ID (GUID) to update"),
   displayName: z.string().optional().describe("New display name for the flow"),
+  description: z.string().optional().describe("New description (set to empty string to clear)"),
   trigger: triggerSchema2.optional().describe("New trigger definition (replaces existing)"),
   triggerName: z.string().optional().describe("Name for the trigger"),
-  actions: z.record(actionSchema2).optional().describe("New actions (replaces all existing actions)"),
+  actions: z.record(actionSchema2).optional().describe(
+    "Actions. By default REPLACES all existing actions (you must include every action you want kept). When mergeActions=true, only the named actions are added/updated; everything else stays. Use patchActions for surgical edits to a single nested branch (smallest payload)."
+  ),
+  mergeActions: z.boolean().optional().default(false).describe(
+    "When true, deep-merge the provided 'actions' onto the current flow's actions instead of replacing wholesale. Recurses into nested actions/cases/else/foreach. Lets you patch a sub-tree without resending the entire flow."
+  ),
+  patchActions: z.record(actionSchema2.nullable()).optional().describe(
+    "Path-based patch map. Keys are slash-separated paths into the action tree, e.g. 'If_Recognized_Form/cases/Default/actions/Compose'. Set value to null to delete a node. Smallest payload \u2014 only the changed branches travel. Applied AFTER mergeActions."
+  ),
   connectionReferences: z.record(connectionRefSchema2).optional().describe("New connection references (replaces existing)"),
   environment: z.string().optional().describe("Environment name or GUID"),
   validateBeforeUpdate: z.boolean().optional().default(true).describe("Validate before updating")
 });
 var updateFlowTool = {
   name: "update_flow",
-  description: "Update an existing Power Automate flow. You can update the display name, trigger, actions, or connection references. Use get_flow first to see the current definition. Note: Updating replaces the entire definition, so include all actions you want to keep.",
+  description: "Update an existing Power Automate flow. Three update modes: (1) full replace \u2014 pass 'actions' to replace all top-level actions (default; you must include nested actions you want kept), (2) merge \u2014 set mergeActions=true to deep-merge only the actions you provide, leaving the rest intact, (3) patch \u2014 use patchActions with path keys (e.g. 'If/cases/Default/actions/Compose') for surgical edits with the smallest payload. Use get_flow with format='json' first to see the full nested action tree.",
   inputSchema: {
     type: "object",
     properties: {
@@ -6029,6 +6178,10 @@ var updateFlowTool = {
         type: "string",
         description: "New display name for the flow"
       },
+      description: {
+        type: "string",
+        description: "New description for the flow (empty string clears)"
+      },
       trigger: {
         type: "object",
         description: "New trigger definition (replaces existing)"
@@ -6039,7 +6192,16 @@ var updateFlowTool = {
       },
       actions: {
         type: "object",
-        description: "New actions (replaces all existing actions)"
+        description: "Actions. By default replaces all existing top-level actions. With mergeActions=true, deep-merges instead."
+      },
+      mergeActions: {
+        type: "boolean",
+        description: "When true, deep-merge 'actions' onto current flow instead of replacing. Recurses into nested actions/cases/else/foreach.",
+        default: false
+      },
+      patchActions: {
+        type: "object",
+        description: "Path-based patch map. Keys: slash-separated paths like 'If/cases/Default/actions/Compose'. Value=null deletes the node. Smallest payload."
       },
       connectionReferences: {
         type: "object",
@@ -6057,17 +6219,80 @@ var updateFlowTool = {
     required: ["flowId"]
   }
 };
+function deepMerge(base, patch) {
+  const out = { ...base };
+  for (const [key, value] of Object.entries(patch)) {
+    if (value === void 0) continue;
+    const baseVal = out[key];
+    if (value !== null && typeof value === "object" && !Array.isArray(value) && baseVal !== null && typeof baseVal === "object" && !Array.isArray(baseVal)) {
+      out[key] = deepMerge(
+        baseVal,
+        value
+      );
+    } else {
+      out[key] = value;
+    }
+  }
+  return out;
+}
+function applyPathPatch(actions, path, value) {
+  const segments = path.split("/").filter(Boolean);
+  if (segments.length === 0) return actions;
+  const result = JSON.parse(JSON.stringify(actions));
+  let cursor = result;
+  for (let i = 0; i < segments.length - 1; i++) {
+    const seg = segments[i];
+    const next = cursor[seg];
+    if (next === null || typeof next !== "object" || Array.isArray(next)) {
+      cursor[seg] = {};
+    }
+    cursor = cursor[seg];
+  }
+  const lastSeg = segments[segments.length - 1];
+  if (value === null) {
+    delete cursor[lastSeg];
+  } else {
+    cursor[lastSeg] = value;
+  }
+  return result;
+}
 async function handleUpdateFlow(api, input) {
   const parsed = updateFlowInputSchema.parse(input);
-  logger.info({ flowId: parsed.flowId }, "Executing update_flow");
+  logger.info(
+    {
+      flowId: parsed.flowId,
+      mergeActions: parsed.mergeActions,
+      hasPatch: !!parsed.patchActions
+    },
+    "Executing update_flow"
+  );
   const currentFlow = await api.getFlow(parsed.flowId, parsed.environment);
   const currentDef = currentFlow.properties.definition;
   const currentConnRefs = currentFlow.properties.connectionReferences;
   const newDisplayName = parsed.displayName ?? currentFlow.properties.displayName;
+  const newDescription = parsed.description !== void 0 ? parsed.description : currentFlow.properties.description;
   let newDefinition;
-  if (parsed.trigger || parsed.actions) {
+  let resolvedActions;
+  if (parsed.actions || parsed.patchActions) {
+    if (parsed.mergeActions && parsed.actions) {
+      resolvedActions = deepMerge(
+        currentDef.actions,
+        parsed.actions
+      );
+    } else if (parsed.actions) {
+      resolvedActions = parsed.actions;
+    } else {
+      resolvedActions = JSON.parse(JSON.stringify(currentDef.actions));
+    }
+    if (parsed.patchActions) {
+      for (const [path, value] of Object.entries(parsed.patchActions)) {
+        resolvedActions = applyPathPatch(resolvedActions, path, value);
+      }
+    }
+  }
+  if (parsed.trigger || resolvedActions) {
     const triggerName = parsed.triggerName ?? Object.keys(currentDef.triggers)[0] ?? "manual";
-    const processedActions = parsed.actions ? preprocessFlowActions(parsed.actions) : currentDef.actions;
+    const processedActions = resolvedActions ? preprocessFlowActions(resolvedActions) : currentDef.actions;
     newDefinition = {
       $schema: currentDef.$schema,
       contentVersion: currentDef.contentVersion,
@@ -6121,7 +6346,8 @@ async function handleUpdateFlow(api, input) {
     properties: {
       displayName: newDisplayName,
       definition: newDefinition,
-      connectionReferences: newConnRefs
+      connectionReferences: newConnRefs,
+      ...newDescription !== void 0 ? { description: newDescription } : {}
     }
   };
   try {
@@ -6670,11 +6896,14 @@ var getRunActionsInputSchema = z.object({
   flowId: z.string().describe("The flow ID (GUID)"),
   runId: z.string().describe("The run ID (GUID)"),
   environment: z.string().optional().describe("Environment name or GUID. Uses default if omitted."),
-  failedOnly: z.boolean().optional().describe("If true, only return failed actions (default: false)")
+  failedOnly: z.boolean().optional().describe("If true, only return failed actions (default: false)"),
+  includeInputs: z.boolean().optional().describe("If true, fetch and display input data for each action (default: false for succeeded, true for failed)"),
+  includeOutputs: z.boolean().optional().describe("If true, fetch and display output data for each action (default: false for succeeded, true for failed)"),
+  actionName: z.string().optional().describe("Filter to a specific action by name (partial match). Use to drill into one action's details.")
 });
 var getRunActionsTool = {
   name: "get_run_actions",
-  description: "Get detailed action-level information for a flow run. Shows each action's status, timing, and most importantly - error details for failed actions. Essential for debugging why a flow failed. Use 'failedOnly: true' to focus on just the failures.",
+  description: "Get detailed action-level information for a flow run. Shows each action's status, timing, inputs/outputs, and error details. Use 'failedOnly: true' to focus on failures, 'actionName' to drill into a specific action, 'includeInputs'/'includeOutputs' to see full data payloads.",
   inputSchema: {
     type: "object",
     properties: {
@@ -6693,11 +6922,34 @@ var getRunActionsTool = {
       failedOnly: {
         type: "boolean",
         description: "If true, only return failed actions (default: false)"
+      },
+      includeInputs: {
+        type: "boolean",
+        description: "If true, fetch and display input data for each action (default: false for succeeded, true for failed)"
+      },
+      includeOutputs: {
+        type: "boolean",
+        description: "If true, fetch and display output data for each action (default: false for succeeded, true for failed)"
+      },
+      actionName: {
+        type: "string",
+        description: "Filter to a specific action by name (partial match). Use to drill into one action's details."
       }
     },
     required: ["flowId", "runId"]
   }
 };
+var TRUNCATE_LIMIT = 1e3;
+var ERROR_TRUNCATE_LIMIT = 500;
+function formatResourceData(data) {
+  if (data && typeof data === "object" && "body" in data) {
+    const body = data.body;
+    const str2 = typeof body === "object" ? JSON.stringify(body, null, 2) : String(body);
+    return str2.length > TRUNCATE_LIMIT ? str2.slice(0, TRUNCATE_LIMIT) + "\u2026" : str2;
+  }
+  const str = JSON.stringify(data, null, 2);
+  return str.length > TRUNCATE_LIMIT ? str.slice(0, TRUNCATE_LIMIT) + "\u2026" : str;
+}
 async function handleGetRunActions(api, input) {
   const parsed = getRunActionsInputSchema.parse(input);
   logger.info({ input: parsed }, "Executing get_run_actions");
@@ -6707,38 +6959,70 @@ async function handleGetRunActions(api, input) {
     parsed.environment
   );
   let filteredActions = actions;
+  if (parsed.actionName) {
+    const needle = parsed.actionName.toLowerCase();
+    filteredActions = filteredActions.filter(
+      (a) => a.name.toLowerCase().includes(needle)
+    );
+  }
   if (parsed.failedOnly) {
-    filteredActions = actions.filter(
+    filteredActions = filteredActions.filter(
       (a) => a.properties.status === "Failed" || a.properties.status === "TimedOut"
     );
   }
-  const keyActionNames = ["Result", "Debug_Sample", "Debug_F1", "Final_Count"];
-  const outputsToFetch = [];
+  const shouldFetchInputs = (status) => {
+    if (parsed.includeInputs === true) return true;
+    if (parsed.includeInputs === false) return false;
+    return status === "Failed" || status === "TimedOut";
+  };
+  const shouldFetchOutputs = (status) => {
+    if (parsed.includeOutputs === true) return true;
+    if (parsed.includeOutputs === false) return false;
+    return status === "Failed" || status === "TimedOut";
+  };
+  const actionIO = {};
+  const fetchPromises = [];
   for (const action of filteredActions) {
-    const isKeyAction = keyActionNames.some((k) => action.name.includes(k) || action.name === k);
-    if (isKeyAction && action.properties.outputsLink?.uri) {
-      outputsToFetch.push({ name: action.name, uri: action.properties.outputsLink.uri });
+    const status = action.properties.status;
+    const needInputs = shouldFetchInputs(status) && action.properties.inputsLink?.uri;
+    const needOutputs = shouldFetchOutputs(status) && action.properties.outputsLink?.uri;
+    if (needInputs) {
+      fetchPromises.push(
+        api.fetchResourceLink(action.properties.inputsLink.uri).then(
+          (data) => {
+            if (!actionIO[action.name]) actionIO[action.name] = {};
+            actionIO[action.name].inputs = formatResourceData(data);
+          },
+          (err) => {
+            if (!actionIO[action.name]) actionIO[action.name] = {};
+            const msg = err instanceof Error ? err.message : String(err);
+            actionIO[action.name].inputs = `(fetch error: ${msg.slice(0, 100)})`;
+          }
+        )
+      );
     }
-  }
-  const actionOutputs = {};
-  for (const { name, uri } of outputsToFetch) {
-    try {
-      const output = await api.fetchResourceLink(uri);
-      if (output && typeof output === "object" && "body" in output) {
-        const body = output.body;
-        actionOutputs[name] = typeof body === "object" ? JSON.stringify(body).slice(0, 200) : String(body);
-      } else {
-        actionOutputs[name] = JSON.stringify(output).slice(0, 200);
-      }
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      actionOutputs[name] = `(error: ${msg.slice(0, 50)})`;
+    if (needOutputs) {
+      fetchPromises.push(
+        api.fetchResourceLink(action.properties.outputsLink.uri).then(
+          (data) => {
+            if (!actionIO[action.name]) actionIO[action.name] = {};
+            actionIO[action.name].outputs = formatResourceData(data);
+          },
+          (err) => {
+            if (!actionIO[action.name]) actionIO[action.name] = {};
+            const msg = err instanceof Error ? err.message : String(err);
+            actionIO[action.name].outputs = `(fetch error: ${msg.slice(0, 100)})`;
+          }
+        )
+      );
     }
   }
-  const result = filteredActions.map((action) => {
+  await Promise.all(fetchPromises);
+  const results = filteredActions.map((action) => {
     const props = action.properties;
     const startTime = new Date(props.startTime);
     const endTime = props.endTime ? new Date(props.endTime) : void 0;
+    const io = actionIO[action.name];
     return {
       name: action.name,
       status: props.status,
@@ -6746,25 +7030,213 @@ async function handleGetRunActions(api, input) {
       endTime: props.endTime,
       durationMs: endTime ? endTime.getTime() - startTime.getTime() : void 0,
       error: props.error,
-      retryCount: props.retryHistory?.length
+      inputs: io?.inputs,
+      outputs: io?.outputs,
+      retryCount: props.retryHistory?.length,
+      trackedProperties: props.trackedProperties
     };
   });
-  const failedCount = result.filter((r) => r.status === "Failed" || r.status === "TimedOut").length;
-  const succeededCount = result.filter((r) => r.status === "Succeeded").length;
-  const lines = [`Actions: ${result.length} total (${succeededCount} succeeded, ${failedCount} failed)`];
-  if (Object.keys(actionOutputs).length > 0) {
-    lines.push("\nOutputs:");
-    for (const [name, value] of Object.entries(actionOutputs)) {
-      lines.push(`  ${name}: ${value}`);
-    }
-    lines.push("");
+  const failedCount = results.filter(
+    (r) => r.status === "Failed" || r.status === "TimedOut"
+  ).length;
+  const succeededCount = results.filter(
+    (r) => r.status === "Succeeded"
+  ).length;
+  const lines = [
+    `Actions: ${results.length} total (${succeededCount} succeeded, ${failedCount} failed)`
+  ];
+  if (parsed.actionName) {
+    lines[0] += ` [filtered by "${parsed.actionName}"]`;
   }
-  for (const action of result) {
+  for (const action of results) {
     const duration = action.durationMs ? `${(action.durationMs / 1e3).toFixed(1)}s` : "";
-    const status = action.status === "Succeeded" ? "\u2713" : action.status === "Failed" ? "\u2717" : "\u25CB";
-    let line = `  ${status} ${action.name} ${duration}`;
+    const status = action.status === "Succeeded" ? "\u2713" : action.status === "Failed" ? "\u2717" : action.status === "TimedOut" ? "\u23F1" : "\u25CB";
+    let line = `
+  ${status} ${action.name} ${duration}`;
     if (action.error) {
-      line += ` - ${action.error.message.slice(0, 100)}`;
+      line += `
+    Error: [${action.error.code}] ${action.error.message.slice(0, ERROR_TRUNCATE_LIMIT)}`;
+    }
+    if (action.inputs) {
+      line += `
+    Inputs: ${action.inputs}`;
+    }
+    if (action.outputs) {
+      line += `
+    Outputs: ${action.outputs}`;
+    }
+    if (action.trackedProperties && Object.keys(action.trackedProperties).length > 0) {
+      line += `
+    Tracked: ${JSON.stringify(action.trackedProperties)}`;
+    }
+    if (action.retryCount && action.retryCount > 0) {
+      line += `
+    Retries: ${action.retryCount}`;
+    }
+    lines.push(line);
+  }
+  return lines.join("\n");
+}
+var getRunActionRepetitionsInputSchema = z.object({
+  flowId: z.string().describe("The flow ID (GUID)"),
+  runId: z.string().describe("The run ID (GUID)"),
+  actionName: z.string().describe("The exact action name inside the for_each/do_until loop"),
+  environment: z.string().optional().describe("Environment name or GUID. Uses default if omitted."),
+  failedOnly: z.boolean().optional().describe("If true, only return failed iterations (default: false)"),
+  includeInputs: z.boolean().optional().describe("If true, fetch input data for each iteration (default: false)"),
+  includeOutputs: z.boolean().optional().describe("If true, fetch output data for each iteration (default: true for failed)"),
+  maxIterations: z.number().optional().describe("Maximum iterations to return (default: 50). Use to limit large loops.")
+});
+var getRunActionRepetitionsTool = {
+  name: "get_run_action_repetitions",
+  description: "Get iteration-level details for a for_each or do_until loop action in a flow run. Shows which iterations succeeded/failed, their inputs/outputs, and error details. Essential for debugging loops that partially fail.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      flowId: {
+        type: "string",
+        description: "The flow ID (GUID)"
+      },
+      runId: {
+        type: "string",
+        description: "The run ID (GUID)"
+      },
+      actionName: {
+        type: "string",
+        description: "The exact action name inside the for_each/do_until loop"
+      },
+      environment: {
+        type: "string",
+        description: "Environment name or GUID. Uses default if omitted."
+      },
+      failedOnly: {
+        type: "boolean",
+        description: "If true, only return failed iterations (default: false)"
+      },
+      includeInputs: {
+        type: "boolean",
+        description: "If true, fetch input data for each iteration (default: false)"
+      },
+      includeOutputs: {
+        type: "boolean",
+        description: "If true, fetch output data for each iteration (default: true for failed)"
+      },
+      maxIterations: {
+        type: "number",
+        description: "Maximum iterations to return (default: 50). Use to limit large loops."
+      }
+    },
+    required: ["flowId", "runId", "actionName"]
+  }
+};
+var TRUNCATE_LIMIT2 = 1e3;
+function formatData(data) {
+  if (data && typeof data === "object" && "body" in data) {
+    const body = data.body;
+    const str2 = typeof body === "object" ? JSON.stringify(body, null, 2) : String(body);
+    return str2.length > TRUNCATE_LIMIT2 ? str2.slice(0, TRUNCATE_LIMIT2) + "\u2026" : str2;
+  }
+  const str = JSON.stringify(data, null, 2);
+  return str.length > TRUNCATE_LIMIT2 ? str.slice(0, TRUNCATE_LIMIT2) + "\u2026" : str;
+}
+async function handleGetRunActionRepetitions(api, input) {
+  const parsed = getRunActionRepetitionsInputSchema.parse(input);
+  const maxIter = parsed.maxIterations ?? 50;
+  logger.info({ input: parsed }, "Executing get_run_action_repetitions");
+  const repetitions = await api.getFlowRunActionRepetitions(
+    parsed.flowId,
+    parsed.runId,
+    parsed.actionName,
+    parsed.environment
+  );
+  let filtered = repetitions;
+  if (parsed.failedOnly) {
+    filtered = filtered.filter(
+      (r) => r.properties.status === "Failed" || r.properties.status === "TimedOut"
+    );
+  }
+  const totalCount = filtered.length;
+  filtered = filtered.slice(0, maxIter);
+  const shouldFetchInputs = (status) => {
+    if (parsed.includeInputs === true) return true;
+    return false;
+  };
+  const shouldFetchOutputs = (status) => {
+    if (parsed.includeOutputs === true) return true;
+    if (parsed.includeOutputs === false) return false;
+    return status === "Failed" || status === "TimedOut";
+  };
+  const iterIO = {};
+  const fetchPromises = [];
+  for (const rep of filtered) {
+    const status = rep.properties.status;
+    const key = rep.name;
+    if (shouldFetchInputs() && rep.properties.inputsLink?.uri) {
+      fetchPromises.push(
+        api.fetchResourceLink(rep.properties.inputsLink.uri).then(
+          (data) => {
+            if (!iterIO[key]) iterIO[key] = {};
+            iterIO[key].inputs = formatData(data);
+          },
+          (err) => {
+            if (!iterIO[key]) iterIO[key] = {};
+            const msg = err instanceof Error ? err.message : String(err);
+            iterIO[key].inputs = `(fetch error: ${msg.slice(0, 100)})`;
+          }
+        )
+      );
+    }
+    if (shouldFetchOutputs(status) && rep.properties.outputsLink?.uri) {
+      fetchPromises.push(
+        api.fetchResourceLink(rep.properties.outputsLink.uri).then(
+          (data) => {
+            if (!iterIO[key]) iterIO[key] = {};
+            iterIO[key].outputs = formatData(data);
+          },
+          (err) => {
+            if (!iterIO[key]) iterIO[key] = {};
+            const msg = err instanceof Error ? err.message : String(err);
+            iterIO[key].outputs = `(fetch error: ${msg.slice(0, 100)})`;
+          }
+        )
+      );
+    }
+  }
+  await Promise.all(fetchPromises);
+  const failedCount = filtered.filter(
+    (r) => r.properties.status === "Failed" || r.properties.status === "TimedOut"
+  ).length;
+  const succeededCount = filtered.filter(
+    (r) => r.properties.status === "Succeeded"
+  ).length;
+  const lines = [
+    `Repetitions for "${parsed.actionName}": ${totalCount} total (${succeededCount} succeeded, ${failedCount} failed)`
+  ];
+  if (totalCount > maxIter) {
+    lines.push(`  (showing first ${maxIter} of ${totalCount})`);
+  }
+  for (const rep of filtered) {
+    const props = rep.properties;
+    const startTime = new Date(props.startTime);
+    const endTime = props.endTime ? new Date(props.endTime) : void 0;
+    const durationMs = endTime ? endTime.getTime() - startTime.getTime() : void 0;
+    const duration = durationMs ? `${(durationMs / 1e3).toFixed(1)}s` : "";
+    const indexes = props.repetitionIndexes?.map((ri) => `${ri.scopeName}[${ri.itemIndex}]`).join(" > ");
+    const status = props.status === "Succeeded" ? "\u2713" : props.status === "Failed" ? "\u2717" : props.status === "TimedOut" ? "\u23F1" : "\u25CB";
+    let line = `
+  ${status} ${indexes ?? rep.name} ${duration}`;
+    if (props.error) {
+      line += `
+    Error: [${props.error.code}] ${props.error.message.slice(0, 500)}`;
+    }
+    const io = iterIO[rep.name];
+    if (io?.inputs) {
+      line += `
+    Inputs: ${io.inputs}`;
+    }
+    if (io?.outputs) {
+      line += `
+    Outputs: ${io.outputs}`;
     }
     lines.push(line);
   }
@@ -12721,6 +13193,7 @@ var tools = [
   // Phase 4: Connections, Diagnostics, Sharing
   listConnectionsTool,
   getRunActionsTool,
+  getRunActionRepetitionsTool,
   getFlowPermissionsTool,
   shareFlowTool,
   // Phase 5: Run Control, Environment Management
@@ -12856,6 +13329,9 @@ async function executeTool(context, toolName, input) {
       case "get_run_actions":
         result = await handleGetRunActions(context.flowApi, input);
         break;
+      case "get_run_action_repetitions":
+        result = await handleGetRunActionRepetitions(context.flowApi, input);
+        break;
       case "get_flow_permissions":
         result = await handleGetFlowPermissions(context.flowApi, input);
         break;